/*

 html2canvas 0.5.0-beta3 <http://html2canvas.hertzen.com>

 Copyright (c) 2016 Niklas von Hertzen



 Released under  License

 */



! function (e) {
    if ("object" == typeof exports && "undefined" != typeof module) module.exports = e();
    else if ("function" == typeof define && define.amd) define([], e);
    else {
        var f;
        "undefined" != typeof window ? f = window : "undefined" != typeof global ? f = global : "undefined" != typeof self && (f = self), f.html2canvas = e()
    }
}(function () {
    var define, module, exports;
    return (function e(t, n, r) {
        function s(o, u) {
            if (!n[o]) {
                if (!t[o]) {
                    var a = typeof require == "function" && require;
                    if (!u && a) return a(o, !0);
                    if (i) return i(o, !0);
                    var f = new Error("Cannot find module '" + o + "'");
                    throw f.code = "MODULE_NOT_FOUND", f
                }
                var l = n[o] = {
                    exports: {}
                };
                t[o][0].call(l.exports, function (e) {
                    var n = t[o][1][e];
                    return s(n ? n : e)
                }, l, l.exports, e, t, n, r)
            }
            return n[o].exports
        }
        var i = typeof require == "function" && require;
        for (var o = 0; o < r.length; o++) s(r[o]);
        return s
    })({
        1: [function (_dereq_, module, exports) {

            (function (global) {

                /*! http://mths.be/punycode v1.2.4 by @mathias */

                ;
                (function (root) {



                    /** Detect free variables */

                    var freeExports = typeof exports == 'object' && exports;

                    var freeModule = typeof module == 'object' && module &&

                        module.exports == freeExports && module;

                    var freeGlobal = typeof global == 'object' && global;

                    if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {

                        root = freeGlobal;

                    }



                    /**

                     * The `punycode` object.

                     * @name punycode

                     * @type Object

                     */

                    var punycode,



                        /** Highest positive signed 32-bit float value */

                        maxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1



                        /** Bootstring parameters */

                        base = 36,

                        tMin = 1,

                        tMax = 26,

                        skew = 38,

                        damp = 700,

                        initialBias = 72,

                        initialN = 128, // 0x80

                        delimiter = '-', // '\x2D'



                        /** Regular expressions */

                        regexPunycode = /^xn--/,

                        regexNonASCII = /[^ -~]/, // unprintable ASCII chars + non-ASCII chars

                        regexSeparators = /\x2E|\u3002|\uFF0E|\uFF61/g, // RFC 3490 separators



                        /** Error messages */

                        errors = {

                            'overflow': 'Overflow: input needs wider integers to process',

                            'not-basic': 'Illegal input >= 0x80 (not a basic code point)',

                            'invalid-input': 'Invalid input'

                        },



                        /** Convenience shortcuts */

                        baseMinusTMin = base - tMin,

                        floor = Math.floor,

                        stringFromCharCode = String.fromCharCode,



                        /** Temporary variable */

                        key;



                    /*--------------------------------------------------------------------------*/



                    /**

                     * A generic error utility function.

                     * @private

                     * @param {String} type The error type.

                     * @returns {Error} Throws a `RangeError` with the applicable error message.

                     */

                    function error(type) {

                        throw RangeError(errors[type]);

                    }



                    /**

                     * A generic `Array#map` utility function.

                     * @private

                     * @param {Array} array The array to iterate over.

                     * @param {Function} callback The function that gets called for every array

                     * item.

                     * @returns {Array} A new array of values returned by the callback function.

                     */

                    function map(array, fn) {

                        var length = array.length;

                        while (length--) {

                            array[length] = fn(array[length]);

                        }

                        return array;

                    }



                    /**

                     * A simple `Array#map`-like wrapper to work with domain name strings.

                     * @private

                     * @param {String} domain The domain name.

                     * @param {Function} callback The function that gets called for every

                     * character.

                     * @returns {Array} A new string of characters returned by the callback

                     * function.

                     */

                    function mapDomain(string, fn) {

                        return map(string.split(regexSeparators), fn).join('.');

                    }



                    /**

                     * Creates an array containing the numeric code points of each Unicode

                     * character in the string. While JavaScript uses UCS-2 internally,

                     * this function will convert a pair of surrogate halves (each of which

                     * UCS-2 exposes as separate characters) into a single code point,

                     * matching UTF-16.

                     * @see `punycode.ucs2.encode`

                     * @see <http://mathiasbynens.be/notes/javascript-encoding>

                     * @memberOf punycode.ucs2

                     * @name decode

                     * @param {String} string The Unicode input string (UCS-2).

                     * @returns {Array} The new array of code points.

                     */

                    function ucs2decode(string) {

                        var output = [],

                            counter = 0,

                            length = string.length,

                            value,

                            extra;

                        while (counter < length) {

                            value = string.charCodeAt(counter++);

                            if (value >= 0xD800 && value <= 0xDBFF && counter < length) {

                                // high surrogate, and there is a next character

                                extra = string.charCodeAt(counter++);

                                if ((extra & 0xFC00) == 0xDC00) { // low surrogate

                                    output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);

                                } else {

                                    // unmatched surrogate; only append this code unit, in case the next

                                    // code unit is the high surrogate of a surrogate pair

                                    output.push(value);

                                    counter--;

                                }

                            } else {

                                output.push(value);

                            }

                        }

                        return output;

                    }



                    /**

                     * Creates a string based on an array of numeric code points.

                     * @see `punycode.ucs2.decode`

                     * @memberOf punycode.ucs2

                     * @name encode

                     * @param {Array} codePoints The array of numeric code points.

                     * @returns {String} The new Unicode string (UCS-2).

                     */

                    function ucs2encode(array) {

                        return map(array, function (value) {

                            var output = '';

                            if (value > 0xFFFF) {

                                value -= 0x10000;

                                output += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);

                                value = 0xDC00 | value & 0x3FF;

                            }

                            output += stringFromCharCode(value);

                            return output;

                        }).join('');

                    }



                    /**

                     * Converts a basic code point into a digit/integer.

                     * @see `digitToBasic()`

                     * @private

                     * @param {Number} codePoint The basic numeric code point value.

                     * @returns {Number} The numeric value of a basic code point (for use in

                     * representing integers) in the range `0` to `base - 1`, or `base` if

                     * the code point does not represent a value.

                     */

                    function basicToDigit(codePoint) {

                        if (codePoint - 48 < 10) {

                            return codePoint - 22;

                        }

                        if (codePoint - 65 < 26) {

                            return codePoint - 65;

                        }

                        if (codePoint - 97 < 26) {

                            return codePoint - 97;

                        }

                        return base;

                    }



                    /**

                     * Converts a digit/integer into a basic code point.

                     * @see `basicToDigit()`

                     * @private

                     * @param {Number} digit The numeric value of a basic code point.

                     * @returns {Number} The basic code point whose value (when used for

                     * representing integers) is `digit`, which needs to be in the range

                     * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is

                     * used; else, the lowercase form is used. The behavior is undefined

                     * if `flag` is non-zero and `digit` has no uppercase form.

                     */

                    function digitToBasic(digit, flag) {

                        //  0..25 map to ASCII a..z or A..Z

                        // 26..35 map to ASCII 0..9

                        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);

                    }



                    /**

                     * Bias adaptation function as per section 3.4 of RFC 3492.

                     * http://tools.ietf.org/html/rfc3492#section-3.4

                     * @private

                     */

                    function adapt(delta, numPoints, firstTime) {

                        var k = 0;

                        delta = firstTime ? floor(delta / damp) : delta >> 1;

                        delta += floor(delta / numPoints);

                        for ( /* no initialization */ ; delta > baseMinusTMin * tMax >> 1; k += base) {

                            delta = floor(delta / baseMinusTMin);

                        }

                        return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));

                    }



                    /**

                     * Converts a Punycode string of ASCII-only symbols to a string of Unicode

                     * symbols.

                     * @memberOf punycode

                     * @param {String} input The Punycode string of ASCII-only symbols.

                     * @returns {String} The resulting string of Unicode symbols.

                     */

                    function decode(input) {

                        // Don't use UCS-2

                        var output = [],

                            inputLength = input.length,

                            out,

                            i = 0,

                            n = initialN,

                            bias = initialBias,

                            basic,

                            j,

                            index,

                            oldi,

                            w,

                            k,

                            digit,

                            t,

                            /** Cached calculation results */

                            baseMinusT;



                        // Handle the basic code points: let `basic` be the number of input code

                        // points before the last delimiter, or `0` if there is none, then copy

                        // the first basic code points to the output.



                        basic = input.lastIndexOf(delimiter);

                        if (basic < 0) {

                            basic = 0;

                        }



                        for (j = 0; j < basic; ++j) {

                            // if it's not a basic code point

                            if (input.charCodeAt(j) >= 0x80) {

                                error('not-basic');

                            }

                            output.push(input.charCodeAt(j));

                        }



                        // Main decoding loop: start just after the last delimiter if any basic code

                        // points were copied; start at the beginning otherwise.



                        for (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */ ) {



                            // `index` is the index of the next character to be consumed.

                            // Decode a generalized variable-length integer into `delta`,

                            // which gets added to `i`. The overflow checking is easier

                            // if we increase `i` as we go, then subtract off its starting

                            // value at the end to obtain `delta`.

                            for (oldi = i, w = 1, k = base; /* no condition */ ; k += base) {



                                if (index >= inputLength) {

                                    error('invalid-input');

                                }



                                digit = basicToDigit(input.charCodeAt(index++));



                                if (digit >= base || digit > floor((maxInt - i) / w)) {

                                    error('overflow');

                                }



                                i += digit * w;

                                t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);



                                if (digit < t) {

                                    break;

                                }



                                baseMinusT = base - t;

                                if (w > floor(maxInt / baseMinusT)) {

                                    error('overflow');

                                }



                                w *= baseMinusT;



                            }



                            out = output.length + 1;

                            bias = adapt(i - oldi, out, oldi == 0);



                            // `i` was supposed to wrap around from `out` to `0`,

                            // incrementing `n` each time, so we'll fix that now:

                            if (floor(i / out) > maxInt - n) {

                                error('overflow');

                            }



                            n += floor(i / out);

                            i %= out;



                            // Insert `n` at position `i` of the output

                            output.splice(i++, 0, n);



                        }



                        return ucs2encode(output);

                    }



                    /**

                     * Converts a string of Unicode symbols to a Punycode string of ASCII-only

                     * symbols.

                     * @memberOf punycode

                     * @param {String} input The string of Unicode symbols.

                     * @returns {String} The resulting Punycode string of ASCII-only symbols.

                     */

                    function encode(input) {

                        var n,

                            delta,

                            handledCPCount,

                            basicLength,

                            bias,

                            j,

                            m,

                            q,

                            k,

                            t,

                            currentValue,

                            output = [],

                            /** `inputLength` will hold the number of code points in `input`. */

                            inputLength,

                            /** Cached calculation results */

                            handledCPCountPlusOne,

                            baseMinusT,

                            qMinusT;



                        // Convert the input in UCS-2 to Unicode

                        input = ucs2decode(input);



                        // Cache the length

                        inputLength = input.length;



                        // Initialize the state

                        n = initialN;

                        delta = 0;

                        bias = initialBias;



                        // Handle the basic code points

                        for (j = 0; j < inputLength; ++j) {

                            currentValue = input[j];

                            if (currentValue < 0x80) {

                                output.push(stringFromCharCode(currentValue));

                            }

                        }



                        handledCPCount = basicLength = output.length;



                        // `handledCPCount` is the number of code points that have been handled;

                        // `basicLength` is the number of basic code points.



                        // Finish the basic string - if it is not empty - with a delimiter

                        if (basicLength) {

                            output.push(delimiter);

                        }



                        // Main encoding loop:

                        while (handledCPCount < inputLength) {



                            // All non-basic code points < n have been handled already. Find the next

                            // larger one:

                            for (m = maxInt, j = 0; j < inputLength; ++j) {

                                currentValue = input[j];

                                if (currentValue >= n && currentValue < m) {

                                    m = currentValue;

                                }

                            }



                            // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,

                            // but guard against overflow

                            handledCPCountPlusOne = handledCPCount + 1;

                            if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {

                                error('overflow');

                            }



                            delta += (m - n) * handledCPCountPlusOne;

                            n = m;



                            for (j = 0; j < inputLength; ++j) {

                                currentValue = input[j];



                                if (currentValue < n && ++delta > maxInt) {

                                    error('overflow');

                                }



                                if (currentValue == n) {

                                    // Represent delta as a generalized variable-length integer

                                    for (q = delta, k = base; /* no condition */ ; k += base) {

                                        t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);

                                        if (q < t) {

                                            break;

                                        }

                                        qMinusT = q - t;

                                        baseMinusT = base - t;

                                        output.push(

                                            stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))

                                        );

                                        q = floor(qMinusT / baseMinusT);

                                    }



                                    output.push(stringFromCharCode(digitToBasic(q, 0)));

                                    bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);

                                    delta = 0;

                                    ++handledCPCount;

                                }

                            }



                            ++delta;

                            ++n;



                        }

                        return output.join('');

                    }



                    /**

                     * Converts a Punycode string representing a domain name to Unicode. Only the

                     * Punycoded parts of the domain name will be converted, i.e. it doesn't

                     * matter if you call it on a string that has already been converted to

                     * Unicode.

                     * @memberOf punycode

                     * @param {String} domain The Punycode domain name to convert to Unicode.

                     * @returns {String} The Unicode representation of the given Punycode

                     * string.

                     */

                    function toUnicode(domain) {

                        return mapDomain(domain, function (string) {

                            return regexPunycode.test(string)

                                ?
                                decode(string.slice(4).toLowerCase())

                                :
                                string;

                        });

                    }



                    /**

                     * Converts a Unicode string representing a domain name to Punycode. Only the

                     * non-ASCII parts of the domain name will be converted, i.e. it doesn't

                     * matter if you call it with a domain that's already in ASCII.

                     * @memberOf punycode

                     * @param {String} domain The domain name to convert, as a Unicode string.

                     * @returns {String} The Punycode representation of the given domain name.

                     */

                    function toASCII(domain) {

                        return mapDomain(domain, function (string) {

                            return regexNonASCII.test(string)

                                ?
                                'xn--' + encode(string)

                                :
                                string;

                        });

                    }



                    /*--------------------------------------------------------------------------*/



                    /** Define the public API */

                    punycode = {

                        /**

                         * A string representing the current Punycode.js version number.

                         * @memberOf punycode

                         * @type String

                         */

                        'version': '1.2.4',

                        /**

                         * An object of methods to convert from JavaScript's internal character

                         * representation (UCS-2) to Unicode code points, and back.

                         * @see <http://mathiasbynens.be/notes/javascript-encoding>

                         * @memberOf punycode

                         * @type Object

                         */

                        'ucs2': {

                            'decode': ucs2decode,

                            'encode': ucs2encode

                        },

                        'decode': decode,

                        'encode': encode,

                        'toASCII': toASCII,

                        'toUnicode': toUnicode

                    };



                    /** Expose `punycode` */

                    // Some AMD build optimizers, like r.js, check for specific condition patterns

                    // like the following:

                    if (

                        typeof define == 'function' &&

                        typeof define.amd == 'object' &&

                        define.amd

                    ) {

                        define('punycode', function () {

                            return punycode;

                        });

                    } else if (freeExports && !freeExports.nodeType) {

                        if (freeModule) { // in Node.js or RingoJS v0.8.0+

                            freeModule.exports = punycode;

                        } else { // in Narwhal or RingoJS v0.7.0-

                            for (key in punycode) {

                                punycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);

                            }

                        }

                    } else { // in Rhino or a web browser

                        root.punycode = punycode;

                    }



                }(this));



            }).call(this, typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})

        }, {}],
        2: [function (_dereq_, module, exports) {

            var log = _dereq_('./log');



            function restoreOwnerScroll(ownerDocument, x, y) {

                if (ownerDocument.defaultView && (x !== ownerDocument.defaultView.pageXOffset || y !== ownerDocument.defaultView.pageYOffset)) {

                    ownerDocument.defaultView.scrollTo(x, y);

                }

            }



            function cloneCanvasContents(canvas, clonedCanvas) {

                try {

                    if (clonedCanvas) {

                        clonedCanvas.width = canvas.width;

                        clonedCanvas.height = canvas.height;

                        clonedCanvas.getContext("2d").putImageData(canvas.getContext("2d").getImageData(0, 0, canvas.width, canvas.height), 0, 0);

                    }

                } catch (e) {

                    log("Unable to copy canvas content from", canvas, e);

                }

            }



            function cloneNode(node, javascriptEnabled) {

                var clone = node.nodeType === 3 ? document.createTextNode(node.nodeValue) : node.cloneNode(false);



                var child = node.firstChild;

                while (child) {

                    if (javascriptEnabled === true || child.nodeType !== 1 || child.nodeName !== 'SCRIPT') {

                        clone.appendChild(cloneNode(child, javascriptEnabled));

                    }

                    child = child.nextSibling;

                }



                if (node.nodeType === 1) {

                    clone._scrollTop = node.scrollTop;

                    clone._scrollLeft = node.scrollLeft;

                    if (node.nodeName === "CANVAS") {

                        cloneCanvasContents(node, clone);

                    } else if (node.nodeName === "TEXTAREA" || node.nodeName === "SELECT") {

                        clone.value = node.value;

                    }

                }



                return clone;

            }



            function initNode(node) {

                if (node.nodeType === 1) {

                    node.scrollTop = node._scrollTop;

                    node.scrollLeft = node._scrollLeft;



                    var child = node.firstChild;

                    while (child) {

                        initNode(child);

                        child = child.nextSibling;

                    }

                }

            }



            module.exports = function (ownerDocument, containerDocument, width, height, options, x, y) {

                var documentElement = cloneNode(ownerDocument.documentElement, options.javascriptEnabled);

                var container = containerDocument.createElement("iframe");



                container.className = "html2canvas-container";

                container.style.visibility = "hidden";

                container.style.position = "fixed";

                container.style.left = "-10000px";

                container.style.top = "0px";

                container.style.border = "0";

                container.width = width;

                container.height = height;

                container.scrolling = "no"; // ios won't scroll without it

                containerDocument.body.appendChild(container);



                return new Promise(function (resolve) {

                    var documentClone = container.contentWindow.document;



                    /* Chrome doesn't detect relative background-images assigned in inline <style> sheets when fetched through getComputedStyle

                     if window url is about:blank, we can assign the url to current by writing onto the document

                     */

                    container.contentWindow.onload = container.onload = function () {

                        var interval = setInterval(function () {

                            if (documentClone.body.childNodes.length > 0) {

                                initNode(documentClone.documentElement);

                                clearInterval(interval);

                                if (options.type === "view") {

                                    container.contentWindow.scrollTo(x, y);

                                    if ((/(iPad|iPhone|iPod)/g).test(navigator.userAgent) && (container.contentWindow.scrollY !== y || container.contentWindow.scrollX !== x)) {

                                        documentClone.documentElement.style.top = (-y) + "px";

                                        documentClone.documentElement.style.left = (-x) + "px";

                                        documentClone.documentElement.style.position = 'absolute';

                                    }

                                }

                                resolve(container);

                            }

                        }, 50);

                    };



                    documentClone.open();

                    documentClone.write("<!DOCTYPE html><html></html>");

                    // Chrome scrolls the parent document for some reason after the write to the cloned window???

                    restoreOwnerScroll(ownerDocument, x, y);

                    documentClone.replaceChild(documentClone.adoptNode(documentElement), documentClone.documentElement);

                    documentClone.close();

                });

            };



        }, {
            "./log": 13
        }],
        3: [function (_dereq_, module, exports) {

            // http://dev.w3.org/csswg/css-color/



            function Color(value) {

                this.r = 0;

                this.g = 0;

                this.b = 0;

                this.a = null;

                var result = this.fromArray(value) ||

                    this.namedColor(value) ||

                    this.rgb(value) ||

                    this.rgba(value) ||

                    this.hex6(value) ||

                    this.hex3(value);

            }



            Color.prototype.darken = function (amount) {

                var a = 1 - amount;

                return new Color([

                    Math.round(this.r * a),

                    Math.round(this.g * a),

                    Math.round(this.b * a),

                    this.a

                ]);

            };



            Color.prototype.isTransparent = function () {

                return this.a === 0;

            };



            Color.prototype.isBlack = function () {

                return this.r === 0 && this.g === 0 && this.b === 0;

            };



            Color.prototype.fromArray = function (array) {

                if (Array.isArray(array)) {

                    this.r = Math.min(array[0], 255);

                    this.g = Math.min(array[1], 255);

                    this.b = Math.min(array[2], 255);

                    if (array.length > 3) {

                        this.a = array[3];

                    }

                }



                return (Array.isArray(array));

            };



            var _hex3 = /^#([a-f0-9]{3})$/i;



            Color.prototype.hex3 = function (value) {

                var match = null;

                if ((match = value.match(_hex3)) !== null) {

                    this.r = parseInt(match[1][0] + match[1][0], 16);

                    this.g = parseInt(match[1][1] + match[1][1], 16);

                    this.b = parseInt(match[1][2] + match[1][2], 16);

                }

                return match !== null;

            };



            var _hex6 = /^#([a-f0-9]{6})$/i;



            Color.prototype.hex6 = function (value) {

                var match = null;

                if ((match = value.match(_hex6)) !== null) {

                    this.r = parseInt(match[1].substring(0, 2), 16);

                    this.g = parseInt(match[1].substring(2, 4), 16);

                    this.b = parseInt(match[1].substring(4, 6), 16);

                }

                return match !== null;

            };





            var _rgb = /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/;



            Color.prototype.rgb = function (value) {

                var match = null;

                if ((match = value.match(_rgb)) !== null) {

                    this.r = Number(match[1]);

                    this.g = Number(match[2]);

                    this.b = Number(match[3]);

                }

                return match !== null;

            };



            var _rgba = /^rgba\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d?\.?\d+)\s*\)$/;



            Color.prototype.rgba = function (value) {

                var match = null;

                if ((match = value.match(_rgba)) !== null) {

                    this.r = Number(match[1]);

                    this.g = Number(match[2]);

                    this.b = Number(match[3]);

                    this.a = Number(match[4]);

                }

                return match !== null;

            };



            Color.prototype.toString = function () {

                return this.a !== null && this.a !== 1 ?

                    "rgba(" + [this.r, this.g, this.b, this.a].join(",") + ")" :

                    "rgb(" + [this.r, this.g, this.b].join(",") + ")";

            };



            Color.prototype.namedColor = function (value) {

                value = value.toLowerCase();

                var color = colors[value];

                if (color) {

                    this.r = color[0];

                    this.g = color[1];

                    this.b = color[2];

                } else if (value === "transparent") {

                    this.r = this.g = this.b = this.a = 0;

                    return true;

                }



                return !!color;

            };



            Color.prototype.isColor = true;



            // JSON.stringify([].slice.call($$('.named-color-table tr'), 1).map(function(row) { return [row.childNodes[3].textContent, row.childNodes[5].textContent.trim().split(",").map(Number)] }).reduce(function(data, row) {data[row[0]] = row[1]; return data}, {}))

            var colors = {

                "aliceblue": [240, 248, 255],

                "antiquewhite": [250, 235, 215],

                "aqua": [0, 255, 255],

                "aquamarine": [127, 255, 212],

                "azure": [240, 255, 255],

                "beige": [245, 245, 220],

                "bisque": [255, 228, 196],

                "black": [0, 0, 0],

                "blanchedalmond": [255, 235, 205],

                "blue": [0, 0, 255],

                "blueviolet": [138, 43, 226],

                "brown": [165, 42, 42],

                "burlywood": [222, 184, 135],

                "cadetblue": [95, 158, 160],

                "chartreuse": [127, 255, 0],

                "chocolate": [210, 105, 30],

                "coral": [255, 127, 80],

                "cornflowerblue": [100, 149, 237],

                "cornsilk": [255, 248, 220],

                "crimson": [220, 20, 60],

                "cyan": [0, 255, 255],

                "darkblue": [0, 0, 139],

                "darkcyan": [0, 139, 139],

                "darkgoldenrod": [184, 134, 11],

                "darkgray": [169, 169, 169],

                "darkgreen": [0, 100, 0],

                "darkgrey": [169, 169, 169],

                "darkkhaki": [189, 183, 107],

                "darkmagenta": [139, 0, 139],

                "darkolivegreen": [85, 107, 47],

                "darkorange": [255, 140, 0],

                "darkorchid": [153, 50, 204],

                "darkred": [139, 0, 0],

                "darksalmon": [233, 150, 122],

                "darkseagreen": [143, 188, 143],

                "darkslateblue": [72, 61, 139],

                "darkslategray": [47, 79, 79],

                "darkslategrey": [47, 79, 79],

                "darkturquoise": [0, 206, 209],

                "darkviolet": [148, 0, 211],

                "deeppink": [255, 20, 147],

                "deepskyblue": [0, 191, 255],

                "dimgray": [105, 105, 105],

                "dimgrey": [105, 105, 105],

                "dodgerblue": [30, 144, 255],

                "firebrick": [178, 34, 34],

                "floralwhite": [255, 250, 240],

                "forestgreen": [34, 139, 34],

                "fuchsia": [255, 0, 255],

                "gainsboro": [220, 220, 220],

                "ghostwhite": [248, 248, 255],

                "gold": [255, 215, 0],

                "goldenrod": [218, 165, 32],

                "gray": [128, 128, 128],

                "green": [0, 128, 0],

                "greenyellow": [173, 255, 47],

                "grey": [128, 128, 128],

                "honeydew": [240, 255, 240],

                "hotpink": [255, 105, 180],

                "indianred": [205, 92, 92],

                "indigo": [75, 0, 130],

                "ivory": [255, 255, 240],

                "khaki": [240, 230, 140],

                "lavender": [230, 230, 250],

                "lavenderblush": [255, 240, 245],

                "lawngreen": [124, 252, 0],

                "lemonchiffon": [255, 250, 205],

                "lightblue": [173, 216, 230],

                "lightcoral": [240, 128, 128],

                "lightcyan": [224, 255, 255],

                "lightgoldenrodyellow": [250, 250, 210],

                "lightgray": [211, 211, 211],

                "lightgreen": [144, 238, 144],

                "lightgrey": [211, 211, 211],

                "lightpink": [255, 182, 193],

                "lightsalmon": [255, 160, 122],

                "lightseagreen": [32, 178, 170],

                "lightskyblue": [135, 206, 250],

                "lightslategray": [119, 136, 153],

                "lightslategrey": [119, 136, 153],

                "lightsteelblue": [176, 196, 222],

                "lightyellow": [255, 255, 224],

                "lime": [0, 255, 0],

                "limegreen": [50, 205, 50],

                "linen": [250, 240, 230],

                "magenta": [255, 0, 255],

                "maroon": [128, 0, 0],

                "mediumaquamarine": [102, 205, 170],

                "mediumblue": [0, 0, 205],

                "mediumorchid": [186, 85, 211],

                "mediumpurple": [147, 112, 219],

                "mediumseagreen": [60, 179, 113],

                "mediumslateblue": [123, 104, 238],

                "mediumspringgreen": [0, 250, 154],

                "mediumturquoise": [72, 209, 204],

                "mediumvioletred": [199, 21, 133],

                "midnightblue": [25, 25, 112],

                "mintcream": [245, 255, 250],

                "mistyrose": [255, 228, 225],

                "moccasin": [255, 228, 181],

                "navajowhite": [255, 222, 173],

                "navy": [0, 0, 128],

                "oldlace": [253, 245, 230],

                "olive": [128, 128, 0],

                "olivedrab": [107, 142, 35],

                "orange": [255, 165, 0],

                "orangered": [255, 69, 0],

                "orchid": [218, 112, 214],

                "palegoldenrod": [238, 232, 170],

                "palegreen": [152, 251, 152],

                "paleturquoise": [175, 238, 238],

                "palevioletred": [219, 112, 147],

                "papayawhip": [255, 239, 213],

                "peachpuff": [255, 218, 185],

                "peru": [205, 133, 63],

                "pink": [255, 192, 203],

                "plum": [221, 160, 221],

                "powderblue": [176, 224, 230],

                "purple": [128, 0, 128],

                "rebeccapurple": [102, 51, 153],

                "red": [255, 0, 0],

                "rosybrown": [188, 143, 143],

                "royalblue": [65, 105, 225],

                "saddlebrown": [139, 69, 19],

                "salmon": [250, 128, 114],

                "sandybrown": [244, 164, 96],

                "seagreen": [46, 139, 87],

                "seashell": [255, 245, 238],

                "sienna": [160, 82, 45],

                "silver": [192, 192, 192],

                "skyblue": [135, 206, 235],

                "slateblue": [106, 90, 205],

                "slategray": [112, 128, 144],

                "slategrey": [112, 128, 144],

                "snow": [255, 250, 250],

                "springgreen": [0, 255, 127],

                "steelblue": [70, 130, 180],

                "tan": [210, 180, 140],

                "teal": [0, 128, 128],

                "thistle": [216, 191, 216],

                "tomato": [255, 99, 71],

                "turquoise": [64, 224, 208],

                "violet": [238, 130, 238],

                "wheat": [245, 222, 179],

                "white": [255, 255, 255],

                "whitesmoke": [245, 245, 245],

                "yellow": [255, 255, 0],

                "yellowgreen": [154, 205, 50]

            };



            module.exports = Color;



        }, {}],
        4: [function (_dereq_, module, exports) {

            var Support = _dereq_('./support');

            var CanvasRenderer = _dereq_('./renderers/canvas');

            var ImageLoader = _dereq_('./imageloader');

            var NodeParser = _dereq_('./nodeparser');

            var NodeContainer = _dereq_('./nodecontainer');

            var log = _dereq_('./log');

            var utils = _dereq_('./utils');

            var createWindowClone = _dereq_('./clone');

            var loadUrlDocument = _dereq_('./proxy').loadUrlDocument;

            var getBounds = utils.getBounds;



            var html2canvasNodeAttribute = "data-html2canvas-node";

            var html2canvasCloneIndex = 0;



            function html2canvas(nodeList, options) {

                var index = html2canvasCloneIndex++;

                options = options || {};

                if (options.logging) {

                    log.options.logging = true;

                    log.options.start = Date.now();

                }



                options.async = typeof (options.async) === "undefined" ? true : options.async;

                options.allowTaint = typeof (options.allowTaint) === "undefined" ? false : options.allowTaint;

                options.removeContainer = typeof (options.removeContainer) === "undefined" ? true : options.removeContainer;

                options.javascriptEnabled = typeof (options.javascriptEnabled) === "undefined" ? false : options.javascriptEnabled;

                options.imageTimeout = typeof (options.imageTimeout) === "undefined" ? 10000 : options.imageTimeout;

                options.renderer = typeof (options.renderer) === "function" ? options.renderer : CanvasRenderer;

                options.strict = !!options.strict;



                if (typeof (nodeList) === "string") {

                    if (typeof (options.proxy) !== "string") {

                        return Promise.reject("Proxy must be used when rendering url");

                    }

                    var width = options.width != null ? options.width : window.innerWidth;

                    var height = options.height != null ? options.height : window.innerHeight;

                    return loadUrlDocument(absoluteUrl(nodeList), options.proxy, document, width, height, options).then(function (container) {

                        return renderWindow(container.contentWindow.document.documentElement, container, options, width, height);

                    });

                }



                var node = ((nodeList === undefined) ? [document.documentElement] : ((nodeList.length) ? nodeList : [nodeList]))[0];

                node.setAttribute(html2canvasNodeAttribute + index, index);

                width = options.width != null ? options.width : node.ownerDocument.defaultView.innerWidth;

                height = options.height != null ? options.height : node.ownerDocument.defaultView.innerHeight;

                return renderDocument(node.ownerDocument, options, width, height, index).then(function (canvas) {

                    if (typeof (options.onrendered) === "function") {

                        log("options.onrendered is deprecated, html2canvas returns a Promise containing the canvas");

                        options.onrendered(canvas);

                    }

                    return canvas;

                });

            }



            html2canvas.CanvasRenderer = CanvasRenderer;

            html2canvas.NodeContainer = NodeContainer;

            html2canvas.log = log;

            html2canvas.utils = utils;



            var html2canvasExport = (typeof (document) === "undefined" || typeof (Object.create) !== "function" || typeof (document.createElement("canvas").getContext) !== "function") ? function () {

                return Promise.reject("No canvas support");

            } : html2canvas;



            module.exports = html2canvasExport;



            if (typeof (define) === 'function' && define.amd) {

                define('html2canvas', [], function () {

                    return html2canvasExport;

                });

            }



            function renderDocument(document, options, windowWidth, windowHeight, html2canvasIndex) {

                return createWindowClone(document, document, windowWidth, windowHeight, options, document.defaultView.pageXOffset, document.defaultView.pageYOffset).then(function (container) {

                    log("Document cloned");



                    var attributeName = html2canvasNodeAttribute + html2canvasIndex;

                    var selector = "[" + attributeName + "='" + html2canvasIndex + "']";

                    document.querySelector(selector).removeAttribute(attributeName);

                    var clonedWindow = container.contentWindow;

                    var node = clonedWindow.document.querySelector(selector);

                    var oncloneHandler = (typeof (options.onclone) === "function") ? Promise.resolve(options.onclone(clonedWindow.document)) : Promise.resolve(true);

                    return oncloneHandler.then(function () {

                        return renderWindow(node, container, options, windowWidth, windowHeight);

                    });

                });

            }



            function renderWindow(node, container, options, windowWidth, windowHeight) {

                var clonedWindow = container.contentWindow;

                var support = new Support(clonedWindow.document);

                var imageLoader = new ImageLoader(options, support);

                var bounds = getBounds(node);

                var width = options.type === "view" ? windowWidth : documentWidth(clonedWindow.document);

                var height = options.type === "view" ? windowHeight : documentHeight(clonedWindow.document);

                console.log()

                var renderer = new options.renderer(width, height, imageLoader, options, node.ownerDocument);

                var parser = new NodeParser(node, renderer, support, imageLoader, options);

                return parser.ready.then(function () {

                    log("Finished rendering");

                    var canvas;

                    if (options.type === "view") {

                        canvas = crop(renderer.canvas, {
                            width: renderer.canvas.width,
                            height: renderer.canvas.height,
                            top: 0,
                            left: 0,
                            x: 0,
                            y: 0
                        });

                    } else if (node === clonedWindow.document.body || node === clonedWindow.document.documentElement) {

                        canvas = renderer.canvas;

                    } else if (options.scale && options.canvas != null) {

                        log("放大canvas", options.canvas);

                        var scale = options.scale || 1;

                        console.log(bounds.top * scale)

                        canvas = crop(renderer.canvas, {
                            width: bounds.width * scale,
                            height: bounds.height * scale,
                            top: bounds.top * scale,
                            left: bounds.left * scale,
                            x: 0,
                            y: 0
                        });

                        // console.log(canvas.width)



                    } else {

                        canvas = crop(renderer.canvas, {
                            width: options.width != null ? options.width : bounds.width,
                            height: options.height != null ? options.height : bounds.height,
                            top: bounds.top,
                            left: bounds.left,
                            x: 0,
                            y: 0
                        });

                    }



                    cleanupContainer(container, options);

                    return canvas;

                });

            }



            function cleanupContainer(container, options) {

                if (options.removeContainer) {

                    container.parentNode.removeChild(container);

                    log("Cleaned up container");

                }

            }



            function crop(canvas, bounds) {

                var croppedCanvas = document.createElement("canvas");

                var x1 = Math.min(canvas.width - 1, Math.max(0, bounds.left));

                var x2 = Math.min(canvas.width, Math.max(1, bounds.left + bounds.width));

                var y1 = Math.min(canvas.height - 1, Math.max(0, bounds.top));

                var y2 = Math.min(canvas.height, Math.max(1, bounds.top + bounds.height));

                croppedCanvas.width = bounds.width;

                croppedCanvas.height = bounds.height;

                var width = x2 - x1;

                var height = y2 - y1;



                log("Cropping canvas at:", "left:", bounds.left, "top:", bounds.top, "width:", width, "height:", height);

                log("Resulting crop with width", bounds.width, "and height", bounds.height, "with x", x1, "and y", y1);

                croppedCanvas.getContext("2d").drawImage(canvas, x1, y1, width, height, bounds.x, bounds.y, width, height);

                return croppedCanvas;

            }



            function documentWidth(doc) {

                return Math.max(

                    Math.max(doc.body.scrollWidth, doc.documentElement.scrollWidth),

                    Math.max(doc.body.offsetWidth, doc.documentElement.offsetWidth),

                    Math.max(doc.body.clientWidth, doc.documentElement.clientWidth)

                );

            }



            function documentHeight(doc) {

                return Math.max(

                    Math.max(doc.body.scrollHeight, doc.documentElement.scrollHeight),

                    Math.max(doc.body.offsetHeight, doc.documentElement.offsetHeight),

                    Math.max(doc.body.clientHeight, doc.documentElement.clientHeight)

                );

            }



            function absoluteUrl(url) {

                var link = document.createElement("a");

                link.href = url;

                link.href = link.href;

                return link;

            }



        }, {
            "./clone": 2,
            "./imageloader": 11,
            "./log": 13,
            "./nodecontainer": 14,
            "./nodeparser": 15,
            "./proxy": 16,
            "./renderers/canvas": 20,
            "./support": 22,
            "./utils": 26
        }],
        5: [function (_dereq_, module, exports) {

            var log = _dereq_('./log');

            var smallImage = _dereq_('./utils').smallImage;



            function DummyImageContainer(src) {

                this.src = src;

                log("DummyImageContainer for", src);

                if (!this.promise || !this.image) {

                    log("Initiating DummyImageContainer");

                    DummyImageContainer.prototype.image = new Image();

                    var image = this.image;

                    DummyImageContainer.prototype.promise = new Promise(function (resolve, reject) {

                        image.onload = resolve;

                        image.onerror = reject;

                        image.src = smallImage();

                        if (image.complete === true) {

                            resolve(image);

                        }

                    });

                }

            }



            module.exports = DummyImageContainer;



        }, {
            "./log": 13,
            "./utils": 26
        }],
        6: [function (_dereq_, module, exports) {

            var smallImage = _dereq_('./utils').smallImage;



            function Font(family, size) {

                var container = document.createElement('div'),

                    img = document.createElement('img'),

                    span = document.createElement('span'),

                    sampleText = 'Hidden Text',

                    baseline,

                    middle;



                container.style.visibility = "hidden";

                container.style.fontFamily = family;

                container.style.fontSize = size;

                container.style.margin = 0;

                container.style.padding = 0;



                document.body.appendChild(container);



                img.src = smallImage();

                img.width = 1;

                img.height = 1;



                img.style.margin = 0;

                img.style.padding = 0;

                img.style.verticalAlign = "baseline";



                span.style.fontFamily = family;

                span.style.fontSize = size;

                span.style.margin = 0;

                span.style.padding = 0;



                span.appendChild(document.createTextNode(sampleText));

                container.appendChild(span);

                container.appendChild(img);

                baseline = (img.offsetTop - span.offsetTop) + 1;



                container.removeChild(span);

                container.appendChild(document.createTextNode(sampleText));



                container.style.lineHeight = "normal";

                img.style.verticalAlign = "super";



                middle = (img.offsetTop - container.offsetTop) + 1;



                document.body.removeChild(container);



                this.baseline = baseline;

                this.lineWidth = 1;

                this.middle = middle;

            }



            module.exports = Font;



        }, {
            "./utils": 26
        }],
        7: [function (_dereq_, module, exports) {

            var Font = _dereq_('./font');



            function FontMetrics() {

                this.data = {};

            }



            FontMetrics.prototype.getMetrics = function (family, size) {

                if (this.data[family + "-" + size] === undefined) {

                    this.data[family + "-" + size] = new Font(family, size);

                }

                return this.data[family + "-" + size];

            };



            module.exports = FontMetrics;



        }, {
            "./font": 6
        }],
        8: [function (_dereq_, module, exports) {

            var utils = _dereq_('./utils');

            var getBounds = utils.getBounds;

            var loadUrlDocument = _dereq_('./proxy').loadUrlDocument;



            function FrameContainer(container, sameOrigin, options) {

                this.image = null;

                this.src = container;

                var self = this;

                var bounds = getBounds(container);

                this.promise = (!sameOrigin ? this.proxyLoad(options.proxy, bounds, options) : new Promise(function (resolve) {

                    if (container.contentWindow.document.URL === "about:blank" || container.contentWindow.document.documentElement == null) {

                        container.contentWindow.onload = container.onload = function () {

                            resolve(container);

                        };

                    } else {

                        resolve(container);

                    }

                })).then(function (container) {

                    var html2canvas = _dereq_('./core');

                    return html2canvas(container.contentWindow.document.documentElement, {
                        type: 'view',
                        width: container.width,
                        height: container.height,
                        proxy: options.proxy,
                        javascriptEnabled: options.javascriptEnabled,
                        removeContainer: options.removeContainer,
                        allowTaint: options.allowTaint,
                        imageTimeout: options.imageTimeout / 2
                    });

                }).then(function (canvas) {

                    return self.image = canvas;

                });

            }



            FrameContainer.prototype.proxyLoad = function (proxy, bounds, options) {

                var container = this.src;

                return loadUrlDocument(container.src, proxy, container.ownerDocument, bounds.width, bounds.height, options);

            };



            module.exports = FrameContainer;



        }, {
            "./core": 4,
            "./proxy": 16,
            "./utils": 26
        }],
        9: [function (_dereq_, module, exports) {

            function GradientContainer(imageData) {

                this.src = imageData.value;

                this.colorStops = [];

                this.type = null;

                this.x0 = 0.5;

                this.y0 = 0.5;

                this.x1 = 0.5;

                this.y1 = 0.5;

                this.promise = Promise.resolve(true);

            }



            GradientContainer.TYPES = {

                LINEAR: 1,

                RADIAL: 2

            };



            // TODO: support hsl[a], negative %/length values

            // TODO: support <angle> (e.g. -?\d{1,3}(?:\.\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )

            GradientContainer.REGEXP_COLORSTOP = /^\s*(rgba?\(\s*\d{1,3},\s*\d{1,3},\s*\d{1,3}(?:,\s*[0-9\.]+)?\s*\)|[a-z]{3,20}|#[a-f0-9]{3,6})(?:\s+(\d{1,3}(?:\.\d+)?)(%|px)?)?(?:\s|$)/i;



            module.exports = GradientContainer;



        }, {}],
        10: [function (_dereq_, module, exports) {

            function ImageContainer(src, cors) {

                this.src = src;

                this.image = new Image();

                var self = this;

                this.tainted = null;

                this.promise = new Promise(function (resolve, reject) {

                    self.image.onload = resolve;

                    self.image.onerror = reject;

                    if (cors) {

                        self.image.crossOrigin = "anonymous";

                    }

                    self.image.src = src;

                    if (self.image.complete === true) {

                        resolve(self.image);

                    }

                });

            }



            module.exports = ImageContainer;



        }, {}],
        11: [function (_dereq_, module, exports) {

            var log = _dereq_('./log');

            var ImageContainer = _dereq_('./imagecontainer');

            var DummyImageContainer = _dereq_('./dummyimagecontainer');

            var ProxyImageContainer = _dereq_('./proxyimagecontainer');

            var FrameContainer = _dereq_('./framecontainer');

            var SVGContainer = _dereq_('./svgcontainer');

            var SVGNodeContainer = _dereq_('./svgnodecontainer');

            var LinearGradientContainer = _dereq_('./lineargradientcontainer');

            var WebkitGradientContainer = _dereq_('./webkitgradientcontainer');

            var bind = _dereq_('./utils').bind;



            function ImageLoader(options, support) {

                this.link = null;

                this.options = options;

                this.support = support;

                this.origin = this.getOrigin(window.location.href);

            }



            ImageLoader.prototype.findImages = function (nodes) {

                var images = [];

                nodes.reduce(function (imageNodes, container) {

                    switch (container.node.nodeName) {

                        case "IMG":

                            return imageNodes.concat([{

                                args: [container.node.src],

                                method: "url"

                            }]);

                        case "svg":

                        case "IFRAME":

                            return imageNodes.concat([{

                                args: [container.node],

                                method: container.node.nodeName

                            }]);

                    }

                    return imageNodes;

                }, []).forEach(this.addImage(images, this.loadImage), this);

                return images;

            };



            ImageLoader.prototype.findBackgroundImage = function (images, container) {

                container.parseBackgroundImages().filter(this.hasImageBackground).forEach(this.addImage(images, this.loadImage), this);

                return images;

            };



            ImageLoader.prototype.addImage = function (images, callback) {

                return function (newImage) {

                    newImage.args.forEach(function (image) {

                        if (!this.imageExists(images, image)) {

                            images.splice(0, 0, callback.call(this, newImage));

                            log('Added image #' + (images.length), typeof (image) === "string" ? image.substring(0, 100) : image);

                        }

                    }, this);

                };

            };



            ImageLoader.prototype.hasImageBackground = function (imageData) {

                return imageData.method !== "none";

            };



            ImageLoader.prototype.loadImage = function (imageData) {

                if (imageData.method === "url") {

                    var src = imageData.args[0];

                    if (this.isSVG(src) && !this.support.svg && !this.options.allowTaint) {

                        return new SVGContainer(src);

                    } else if (src.match(/data:image\/.*;base64,/i)) {

                        return new ImageContainer(src.replace(/url\(['"]{0,}|['"]{0,}\)$/ig, ''), false);

                    } else if (this.isSameOrigin(src) || this.options.allowTaint === true || this.isSVG(src)) {

                        return new ImageContainer(src, false);

                    } else if (this.support.cors && !this.options.allowTaint && this.options.useCORS) {

                        return new ImageContainer(src, true);

                    } else if (this.options.proxy) {

                        return new ProxyImageContainer(src, this.options.proxy);

                    } else {

                        return new DummyImageContainer(src);

                    }

                } else if (imageData.method === "linear-gradient") {

                    return new LinearGradientContainer(imageData);

                } else if (imageData.method === "gradient") {

                    return new WebkitGradientContainer(imageData);

                } else if (imageData.method === "svg") {

                    return new SVGNodeContainer(imageData.args[0], this.support.svg);

                } else if (imageData.method === "IFRAME") {

                    return new FrameContainer(imageData.args[0], this.isSameOrigin(imageData.args[0].src), this.options);

                } else {

                    return new DummyImageContainer(imageData);

                }

            };



            ImageLoader.prototype.isSVG = function (src) {

                return src.substring(src.length - 3).toLowerCase() === "svg" || SVGContainer.prototype.isInline(src);

            };



            ImageLoader.prototype.imageExists = function (images, src) {

                return images.some(function (image) {

                    return image.src === src;

                });

            };



            ImageLoader.prototype.isSameOrigin = function (url) {

                return (this.getOrigin(url) === this.origin);

            };



            ImageLoader.prototype.getOrigin = function (url) {

                var link = this.link || (this.link = document.createElement("a"));

                link.href = url;

                link.href = link.href; // IE9, LOL! - http://jsfiddle.net/niklasvh/2e48b/

                return link.protocol + link.hostname + link.port;

            };



            ImageLoader.prototype.getPromise = function (container) {

                return this.timeout(container, this.options.imageTimeout)['catch'](function () {

                    var dummy = new DummyImageContainer(container.src);

                    return dummy.promise.then(function (image) {

                        container.image = image;

                    });

                });

            };



            ImageLoader.prototype.get = function (src) {

                var found = null;

                return this.images.some(function (img) {

                    return (found = img).src === src;

                }) ? found : null;

            };



            ImageLoader.prototype.fetch = function (nodes) {

                this.images = nodes.reduce(bind(this.findBackgroundImage, this), this.findImages(nodes));

                this.images.forEach(function (image, index) {

                    image.promise.then(function () {

                        log("Succesfully loaded image #" + (index + 1), image);

                    }, function (e) {

                        log("Failed loading image #" + (index + 1), image, e);

                    });

                });

                this.ready = Promise.all(this.images.map(this.getPromise, this));

                log("Finished searching images");

                return this;

            };



            ImageLoader.prototype.timeout = function (container, timeout) {

                var timer;

                var promise = Promise.race([container.promise, new Promise(function (res, reject) {

                    timer = setTimeout(function () {

                        log("Timed out loading image", container);

                        reject(container);

                    }, timeout);

                })]).then(function (container) {

                    clearTimeout(timer);

                    return container;

                });

                promise['catch'](function () {

                    clearTimeout(timer);

                });

                return promise;

            };



            module.exports = ImageLoader;



        }, {
            "./dummyimagecontainer": 5,
            "./framecontainer": 8,
            "./imagecontainer": 10,
            "./lineargradientcontainer": 12,
            "./log": 13,
            "./proxyimagecontainer": 17,
            "./svgcontainer": 23,
            "./svgnodecontainer": 24,
            "./utils": 26,
            "./webkitgradientcontainer": 27
        }],
        12: [function (_dereq_, module, exports) {

            var GradientContainer = _dereq_('./gradientcontainer');

            var Color = _dereq_('./color');



            function LinearGradientContainer(imageData) {

                GradientContainer.apply(this, arguments);

                this.type = GradientContainer.TYPES.LINEAR;



                var hasDirection = LinearGradientContainer.REGEXP_DIRECTION.test(imageData.args[0]) ||

                    !GradientContainer.REGEXP_COLORSTOP.test(imageData.args[0]);



                if (hasDirection) {

                    imageData.args[0].split(/\s+/).reverse().forEach(function (position, index) {

                        switch (position) {

                            case "left":

                                this.x0 = 0;

                                this.x1 = 1;

                                break;

                            case "top":

                                this.y0 = 0;

                                this.y1 = 1;

                                break;

                            case "right":

                                this.x0 = 1;

                                this.x1 = 0;

                                break;

                            case "bottom":

                                this.y0 = 1;

                                this.y1 = 0;

                                break;

                            case "to":

                                var y0 = this.y0;

                                var x0 = this.x0;

                                this.y0 = this.y1;

                                this.x0 = this.x1;

                                this.x1 = x0;

                                this.y1 = y0;

                                break;

                            case "center":

                                break; // centered by default

                                // Firefox internally converts position keywords to percentages:

                                // http://www.w3.org/TR/2010/WD-CSS2-20101207/colors.html#propdef-background-position

                            default: // percentage or absolute length

                                // TODO: support absolute start point positions (e.g., use bounds to convert px to a ratio)

                                var ratio = parseFloat(position, 10) * 1e-2;

                                if (isNaN(ratio)) { // invalid or unhandled value

                                    break;

                                }

                                if (index === 0) {

                                    this.y0 = ratio;

                                    this.y1 = 1 - this.y0;

                                } else {

                                    this.x0 = ratio;

                                    this.x1 = 1 - this.x0;

                                }

                                break;

                        }

                    }, this);

                } else {

                    this.y0 = 0;

                    this.y1 = 1;

                }



                this.colorStops = imageData.args.slice(hasDirection ? 1 : 0).map(function (colorStop) {

                    var colorStopMatch = colorStop.match(GradientContainer.REGEXP_COLORSTOP);

                    var value = +colorStopMatch[2];

                    var unit = value === 0 ? "%" : colorStopMatch[3]; // treat "0" as "0%"

                    return {

                        color: new Color(colorStopMatch[1]),

                        // TODO: support absolute stop positions (e.g., compute gradient line length & convert px to ratio)

                        stop: unit === "%" ? value / 100 : null

                    };

                });



                if (this.colorStops[0].stop === null) {

                    this.colorStops[0].stop = 0;

                }



                if (this.colorStops[this.colorStops.length - 1].stop === null) {

                    this.colorStops[this.colorStops.length - 1].stop = 1;

                }



                // calculates and fills-in explicit stop positions when omitted from rule

                this.colorStops.forEach(function (colorStop, index) {

                    if (colorStop.stop === null) {

                        this.colorStops.slice(index).some(function (find, count) {

                            if (find.stop !== null) {

                                colorStop.stop = ((find.stop - this.colorStops[index - 1].stop) / (count + 1)) + this.colorStops[index - 1].stop;

                                return true;

                            } else {

                                return false;

                            }

                        }, this);

                    }

                }, this);

            }



            LinearGradientContainer.prototype = Object.create(GradientContainer.prototype);



            // TODO: support <angle> (e.g. -?\d{1,3}(?:\.\d+)deg, etc. : https://developer.mozilla.org/docs/Web/CSS/angle )

            LinearGradientContainer.REGEXP_DIRECTION = /^\s*(?:to|left|right|top|bottom|center|\d{1,3}(?:\.\d+)?%?)(?:\s|$)/i;



            module.exports = LinearGradientContainer;



        }, {
            "./color": 3,
            "./gradientcontainer": 9
        }],
        13: [function (_dereq_, module, exports) {

            var logger = function () {

                if (logger.options.logging && window.console && window.console.log) {

                    Function.prototype.bind.call(window.console.log, (window.console)).apply(window.console, [(Date.now() - logger.options.start) + "ms", "html2canvas:"].concat([].slice.call(arguments, 0)));

                }

            };



            logger.options = {
                logging: false
            };

            module.exports = logger;



        }, {}],
        14: [function (_dereq_, module, exports) {

            var Color = _dereq_('./color');

            var utils = _dereq_('./utils');

            var getBounds = utils.getBounds;

            var parseBackgrounds = utils.parseBackgrounds;

            var offsetBounds = utils.offsetBounds;



            function NodeContainer(node, parent) {

                this.node = node;

                this.parent = parent;

                this.stack = null;

                this.bounds = null;

                this.borders = null;

                this.clip = [];

                this.backgroundClip = [];

                this.offsetBounds = null;

                this.visible = null;

                this.computedStyles = null;

                this.colors = {};

                this.styles = {};

                this.backgroundImages = null;

                this.transformData = null;

                this.transformMatrix = null;

                this.isPseudoElement = false;

                this.opacity = null;

            }



            NodeContainer.prototype.cloneTo = function (stack) {

                stack.visible = this.visible;

                stack.borders = this.borders;

                stack.bounds = this.bounds;

                stack.clip = this.clip;

                stack.backgroundClip = this.backgroundClip;

                stack.computedStyles = this.computedStyles;

                stack.styles = this.styles;

                stack.backgroundImages = this.backgroundImages;

                stack.opacity = this.opacity;

            };



            NodeContainer.prototype.getOpacity = function () {

                return this.opacity === null ? (this.opacity = this.cssFloat('opacity')) : this.opacity;

            };



            NodeContainer.prototype.assignStack = function (stack) {

                this.stack = stack;

                stack.children.push(this);

            };



            NodeContainer.prototype.isElementVisible = function () {

                return this.node.nodeType === Node.TEXT_NODE ? this.parent.visible : (

                    this.css('display') !== "none" &&

                    this.css('visibility') !== "hidden" &&

                    !this.node.hasAttribute("data-html2canvas-ignore") &&

                    (this.node.nodeName !== "INPUT" || this.node.getAttribute("type") !== "hidden")

                );

            };



            NodeContainer.prototype.css = function (attribute) {

                if (!this.computedStyles) {

                    this.computedStyles = this.isPseudoElement ? this.parent.computedStyle(this.before ? ":before" : ":after") : this.computedStyle(null);

                }



                return this.styles[attribute] || (this.styles[attribute] = this.computedStyles[attribute]);

            };



            NodeContainer.prototype.prefixedCss = function (attribute) {

                var prefixes = ["webkit", "moz", "ms", "o"];

                var value = this.css(attribute);

                if (value === undefined) {

                    prefixes.some(function (prefix) {

                        value = this.css(prefix + attribute.substr(0, 1).toUpperCase() + attribute.substr(1));

                        return value !== undefined;

                    }, this);

                }

                return value === undefined ? null : value;

            };



            NodeContainer.prototype.computedStyle = function (type) {

                return this.node.ownerDocument.defaultView.getComputedStyle(this.node, type);

            };



            NodeContainer.prototype.cssInt = function (attribute) {

                var value = parseInt(this.css(attribute), 10);

                return (isNaN(value)) ? 0 : value; // borders in old IE are throwing 'medium' for demo.html

            };



            NodeContainer.prototype.color = function (attribute) {

                return this.colors[attribute] || (this.colors[attribute] = new Color(this.css(attribute)));

            };



            NodeContainer.prototype.cssFloat = function (attribute) {

                var value = parseFloat(this.css(attribute));

                return (isNaN(value)) ? 0 : value;

            };



            NodeContainer.prototype.fontWeight = function () {

                var weight = this.css("fontWeight");

                switch (parseInt(weight, 10)) {

                    case 401:

                        weight = "bold";

                        break;

                    case 400:

                        weight = "normal";

                        break;

                }

                return weight;

            };



            NodeContainer.prototype.parseClip = function () {

                var matches = this.css('clip').match(this.CLIP);

                if (matches) {

                    return {

                        top: parseInt(matches[1], 10),

                        right: parseInt(matches[2], 10),

                        bottom: parseInt(matches[3], 10),

                        left: parseInt(matches[4], 10)

                    };

                }

                return null;

            };



            NodeContainer.prototype.parseBackgroundImages = function () {

                return this.backgroundImages || (this.backgroundImages = parseBackgrounds(this.css("backgroundImage")));

            };



            NodeContainer.prototype.cssList = function (property, index) {

                var value = (this.css(property) || '').split(',');

                value = value[index || 0] || value[0] || 'auto';

                value = value.trim().split(' ');

                if (value.length === 1) {

                    value = [value[0], isPercentage(value[0]) ? 'auto' : value[0]];

                }

                return value;

            };



            NodeContainer.prototype.parseBackgroundSize = function (bounds, image, index) {

                var size = this.cssList("backgroundSize", index);

                var width, height;



                if (isPercentage(size[0])) {

                    width = bounds.width * parseFloat(size[0]) / 100;

                } else if (/contain|cover/.test(size[0])) {

                    var targetRatio = bounds.width / bounds.height,
                        currentRatio = image.width / image.height;

                    return (targetRatio < currentRatio ^ size[0] === 'contain') ? {
                        width: bounds.height * currentRatio,
                        height: bounds.height
                    } : {
                        width: bounds.width,
                        height: bounds.width / currentRatio
                    };

                } else {

                    width = parseInt(size[0], 10);

                }



                if (size[0] === 'auto' && size[1] === 'auto') {

                    height = image.height;

                } else if (size[1] === 'auto') {

                    height = width / image.width * image.height;

                } else if (isPercentage(size[1])) {

                    height = bounds.height * parseFloat(size[1]) / 100;

                } else {

                    height = parseInt(size[1], 10);

                }



                if (size[0] === 'auto') {

                    width = height / image.height * image.width;

                }



                return {
                    width: width,
                    height: height
                };

            };



            NodeContainer.prototype.parseBackgroundPosition = function (bounds, image, index, backgroundSize) {

                var position = this.cssList('backgroundPosition', index);

                var left, top;



                if (isPercentage(position[0])) {

                    left = (bounds.width - (backgroundSize || image).width) * (parseFloat(position[0]) / 100);

                } else {

                    left = parseInt(position[0], 10);

                }



                if (position[1] === 'auto') {

                    top = left / image.width * image.height;

                } else if (isPercentage(position[1])) {

                    top = (bounds.height - (backgroundSize || image).height) * parseFloat(position[1]) / 100;

                } else {

                    top = parseInt(position[1], 10);

                }



                if (position[0] === 'auto') {

                    left = top / image.height * image.width;

                }



                return {
                    left: left,
                    top: top
                };

            };



            NodeContainer.prototype.parseBackgroundRepeat = function (index) {

                return this.cssList("backgroundRepeat", index)[0];

            };



            NodeContainer.prototype.parseTextShadows = function () {

                var textShadow = this.css("textShadow");

                var results = [];



                if (textShadow && textShadow !== 'none') {

                    var shadows = textShadow.match(this.TEXT_SHADOW_PROPERTY);

                    for (var i = 0; shadows && (i < shadows.length); i++) {

                        var s = shadows[i].match(this.TEXT_SHADOW_VALUES);

                        results.push({

                            color: new Color(s[0]),

                            offsetX: s[1] ? parseFloat(s[1].replace('px', '')) : 0,

                            offsetY: s[2] ? parseFloat(s[2].replace('px', '')) : 0,

                            blur: s[3] ? s[3].replace('px', '') : 0

                        });

                    }

                }

                return results;

            };



            NodeContainer.prototype.parseTransform = function () {

                if (!this.transformData) {

                    if (this.hasTransform()) {

                        var offset = this.parseBounds();

                        var origin = this.prefixedCss("transformOrigin").split(" ").map(removePx).map(asFloat);

                        origin[0] += offset.left;

                        origin[1] += offset.top;

                        this.transformData = {

                            origin: origin,

                            matrix: this.parseTransformMatrix()

                        };

                    } else {

                        this.transformData = {

                            origin: [0, 0],

                            matrix: [1, 0, 0, 1, 0, 0]

                        };

                    }

                }

                return this.transformData;

            };



            NodeContainer.prototype.parseTransformMatrix = function () {

                if (!this.transformMatrix) {

                    var transform = this.prefixedCss("transform");

                    var matrix = transform ? parseMatrix(transform.match(this.MATRIX_PROPERTY)) : null;

                    this.transformMatrix = matrix ? matrix : [1, 0, 0, 1, 0, 0];

                }

                return this.transformMatrix;

            };



            NodeContainer.prototype.parseBounds = function () {

                return this.bounds || (this.bounds = this.hasTransform() ? offsetBounds(this.node) : getBounds(this.node));

            };



            NodeContainer.prototype.hasTransform = function () {

                return this.parseTransformMatrix().join(",") !== "1,0,0,1,0,0" || (this.parent && this.parent.hasTransform());

            };



            NodeContainer.prototype.getValue = function () {

                var value = this.node.value || "";

                if (this.node.tagName === "SELECT") {

                    value = selectionValue(this.node);

                } else if (this.node.type === "password") {

                    value = Array(value.length + 1).join('\u2022'); // jshint ignore:line

                }

                return value.length === 0 ? (this.node.placeholder || "") : value;

            };



            NodeContainer.prototype.MATRIX_PROPERTY = /(matrix|matrix3d)\((.+)\)/;

            NodeContainer.prototype.TEXT_SHADOW_PROPERTY = /((rgba|rgb)\([^\)]+\)(\s-?\d+px){0,})/g;

            NodeContainer.prototype.TEXT_SHADOW_VALUES = /(-?\d+px)|(#.+)|(rgb\(.+\))|(rgba\(.+\))/g;

            NodeContainer.prototype.CLIP = /^rect\((\d+)px,? (\d+)px,? (\d+)px,? (\d+)px\)$/;



            function selectionValue(node) {

                var option = node.options[node.selectedIndex || 0];

                return option ? (option.text || "") : "";

            }



            function parseMatrix(match) {

                if (match && match[1] === "matrix") {

                    return match[2].split(",").map(function (s) {

                        return parseFloat(s.trim());

                    });

                } else if (match && match[1] === "matrix3d") {

                    var matrix3d = match[2].split(",").map(function (s) {

                        return parseFloat(s.trim());

                    });

                    return [matrix3d[0], matrix3d[1], matrix3d[4], matrix3d[5], matrix3d[12], matrix3d[13]];

                }

            }



            function isPercentage(value) {

                return value.toString().indexOf("%") !== -1;

            }



            function removePx(str) {

                return str.replace("px", "");

            }



            function asFloat(str) {

                return parseFloat(str);

            }



            module.exports = NodeContainer;



        }, {
            "./color": 3,
            "./utils": 26
        }],
        15: [function (_dereq_, module, exports) {

            var log = _dereq_('./log');

            var punycode = _dereq_('punycode');

            var NodeContainer = _dereq_('./nodecontainer');

            var TextContainer = _dereq_('./textcontainer');

            var PseudoElementContainer = _dereq_('./pseudoelementcontainer');

            var FontMetrics = _dereq_('./fontmetrics');

            var Color = _dereq_('./color');

            var StackingContext = _dereq_('./stackingcontext');

            var utils = _dereq_('./utils');

            var bind = utils.bind;

            var getBounds = utils.getBounds;

            var parseBackgrounds = utils.parseBackgrounds;

            var offsetBounds = utils.offsetBounds;



            function NodeParser(element, renderer, support, imageLoader, options) {

                log("Starting NodeParser");

                this.renderer = renderer;

                this.options = options;

                this.range = null;

                this.support = support;

                this.renderQueue = [];

                this.stack = new StackingContext(true, 1, element.ownerDocument, null);

                var parent = new NodeContainer(element, null);

                if (options.background) {

                    renderer.rectangle(0, 0, renderer.width, renderer.height, new Color(options.background));

                }

                if (element === element.ownerDocument.documentElement) {

                    // http://www.w3.org/TR/css3-background/#special-backgrounds

                    var canvasBackground = new NodeContainer(parent.color('backgroundColor').isTransparent() ? element.ownerDocument.body : element.ownerDocument.documentElement, null);

                    renderer.rectangle(0, 0, renderer.width, renderer.height, canvasBackground.color('backgroundColor'));

                }

                parent.visibile = parent.isElementVisible();

                this.createPseudoHideStyles(element.ownerDocument);

                this.disableAnimations(element.ownerDocument);

                this.nodes = flatten([parent].concat(this.getChildren(parent)).filter(function (container) {

                    return container.visible = container.isElementVisible();

                }).map(this.getPseudoElements, this));

                this.fontMetrics = new FontMetrics();

                log("Fetched nodes, total:", this.nodes.length);

                log("Calculate overflow clips");

                this.calculateOverflowClips();

                log("Start fetching images");

                this.images = imageLoader.fetch(this.nodes.filter(isElement));

                this.ready = this.images.ready.then(bind(function () {

                    log("Images loaded, starting parsing");

                    log("Creating stacking contexts");

                    this.createStackingContexts();

                    log("Sorting stacking contexts");

                    this.sortStackingContexts(this.stack);

                    this.parse(this.stack);

                    log("Render queue created with " + this.renderQueue.length + " items");

                    return new Promise(bind(function (resolve) {

                        if (!options.async) {

                            this.renderQueue.forEach(this.paint, this);

                            resolve();

                        } else if (typeof (options.async) === "function") {

                            options.async.call(this, this.renderQueue, resolve);

                        } else if (this.renderQueue.length > 0) {

                            this.renderIndex = 0;

                            this.asyncRenderer(this.renderQueue, resolve);

                        } else {

                            resolve();

                        }

                    }, this));

                }, this));

            }



            NodeParser.prototype.calculateOverflowClips = function () {

                this.nodes.forEach(function (container) {

                    if (isElement(container)) {

                        if (isPseudoElement(container)) {

                            container.appendToDOM();

                        }

                        container.borders = this.parseBorders(container);

                        var clip = (container.css('overflow') === "hidden") ? [container.borders.clip] : [];

                        var cssClip = container.parseClip();

                        if (cssClip && ["absolute", "fixed"].indexOf(container.css('position')) !== -1) {

                            clip.push([
                                ["rect",

                                    container.bounds.left + cssClip.left,

                                    container.bounds.top + cssClip.top,

                                    cssClip.right - cssClip.left,

                                    cssClip.bottom - cssClip.top

                                ]
                            ]);

                        }

                        container.clip = hasParentClip(container) ? container.parent.clip.concat(clip) : clip;

                        container.backgroundClip = (container.css('overflow') !== "hidden") ? container.clip.concat([container.borders.clip]) : container.clip;

                        if (isPseudoElement(container)) {

                            container.cleanDOM();

                        }

                    } else if (isTextNode(container)) {

                        container.clip = hasParentClip(container) ? container.parent.clip : [];

                    }

                    if (!isPseudoElement(container)) {

                        container.bounds = null;

                    }

                }, this);

            };



            function hasParentClip(container) {

                return container.parent && container.parent.clip.length;

            }



            NodeParser.prototype.asyncRenderer = function (queue, resolve, asyncTimer) {

                asyncTimer = asyncTimer || Date.now();

                this.paint(queue[this.renderIndex++]);

                if (queue.length === this.renderIndex) {

                    resolve();

                } else if (asyncTimer + 20 > Date.now()) {

                    this.asyncRenderer(queue, resolve, asyncTimer);

                } else {

                    setTimeout(bind(function () {

                        this.asyncRenderer(queue, resolve);

                    }, this), 0);

                }

            };



            NodeParser.prototype.createPseudoHideStyles = function (document) {

                this.createStyles(document, '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + ':before { content: "" !important; display: none !important; }' +

                    '.' + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER + ':after { content: "" !important; display: none !important; }');

            };



            NodeParser.prototype.disableAnimations = function (document) {

                this.createStyles(document, '* { -webkit-animation: none !important; -moz-animation: none !important; -o-animation: none !important; animation: none !important; ' +

                    '-webkit-transition: none !important; -moz-transition: none !important; -o-transition: none !important; transition: none !important;}');

            };



            NodeParser.prototype.createStyles = function (document, styles) {

                var hidePseudoElements = document.createElement('style');

                hidePseudoElements.innerHTML = styles;

                document.body.appendChild(hidePseudoElements);

            };



            NodeParser.prototype.getPseudoElements = function (container) {

                var nodes = [
                    [container]
                ];

                if (container.node.nodeType === Node.ELEMENT_NODE) {

                    var before = this.getPseudoElement(container, ":before");

                    var after = this.getPseudoElement(container, ":after");



                    if (before) {

                        nodes.push(before);

                    }



                    if (after) {

                        nodes.push(after);

                    }

                }

                return flatten(nodes);

            };



            function toCamelCase(str) {

                return str.replace(/(\-[a-z])/g, function (match) {

                    return match.toUpperCase().replace('-', '');

                });

            }



            NodeParser.prototype.getPseudoElement = function (container, type) {

                var style = container.computedStyle(type);

                if (!style || !style.content || style.content === "none" || style.content === "-moz-alt-content" || style.display === "none") {

                    return null;

                }



                var content = stripQuotes(style.content);

                var isImage = content.substr(0, 3) === 'url';

                var pseudoNode = document.createElement(isImage ? 'img' : 'html2canvaspseudoelement');

                var pseudoContainer = new PseudoElementContainer(pseudoNode, container, type);



                for (var i = style.length - 1; i >= 0; i--) {

                    var property = toCamelCase(style.item(i));

                    pseudoNode.style[property] = style[property];

                }



                pseudoNode.className = PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE + " " + PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER;



                if (isImage) {

                    pseudoNode.src = parseBackgrounds(content)[0].args[0];

                    return [pseudoContainer];

                } else {

                    var text = document.createTextNode(content);

                    pseudoNode.appendChild(text);

                    return [pseudoContainer, new TextContainer(text, pseudoContainer)];

                }

            };





            NodeParser.prototype.getChildren = function (parentContainer) {

                return flatten([].filter.call(parentContainer.node.childNodes, renderableNode).map(function (node) {

                    var container = [node.nodeType === Node.TEXT_NODE ? new TextContainer(node, parentContainer) : new NodeContainer(node, parentContainer)].filter(nonIgnoredElement);

                    return node.nodeType === Node.ELEMENT_NODE && container.length && node.tagName !== "TEXTAREA" ? (container[0].isElementVisible() ? container.concat(this.getChildren(container[0])) : []) : container;

                }, this));

            };



            NodeParser.prototype.newStackingContext = function (container, hasOwnStacking) {

                var stack = new StackingContext(hasOwnStacking, container.getOpacity(), container.node, container.parent);

                container.cloneTo(stack);

                var parentStack = hasOwnStacking ? stack.getParentStack(this) : stack.parent.stack;

                parentStack.contexts.push(stack);

                container.stack = stack;

            };



            NodeParser.prototype.createStackingContexts = function () {

                this.nodes.forEach(function (container) {

                    if (isElement(container) && (this.isRootElement(container) || hasOpacity(container) || isPositionedForStacking(container) || this.isBodyWithTransparentRoot(container) || container.hasTransform())) {

                        this.newStackingContext(container, true);

                    } else if (isElement(container) && ((isPositioned(container) && zIndex0(container)) || isInlineBlock(container) || isFloating(container))) {

                        this.newStackingContext(container, false);

                    } else {

                        container.assignStack(container.parent.stack);

                    }

                }, this);

            };



            NodeParser.prototype.isBodyWithTransparentRoot = function (container) {

                return container.node.nodeName === "BODY" && container.parent.color('backgroundColor').isTransparent();

            };



            NodeParser.prototype.isRootElement = function (container) {

                return container.parent === null;

            };



            NodeParser.prototype.sortStackingContexts = function (stack) {

                stack.contexts.sort(zIndexSort(stack.contexts.slice(0)));

                stack.contexts.forEach(this.sortStackingContexts, this);

            };



            NodeParser.prototype.parseTextBounds = function (container) {

                return function (text, index, textList) {

                    if (container.parent.css("textDecoration").substr(0, 4) !== "none" || text.trim().length !== 0) {

                        if (this.support.rangeBounds && !container.parent.hasTransform()) {

                            var offset = textList.slice(0, index).join("").length;

                            return this.getRangeBounds(container.node, offset, text.length);

                        } else if (container.node && typeof (container.node.data) === "string") {

                            var replacementNode = container.node.splitText(text.length);

                            var bounds = this.getWrapperBounds(container.node, container.parent.hasTransform());

                            container.node = replacementNode;

                            return bounds;

                        }

                    } else if (!this.support.rangeBounds || container.parent.hasTransform()) {

                        container.node = container.node.splitText(text.length);

                    }

                    return {};

                };

            };



            NodeParser.prototype.getWrapperBounds = function (node, transform) {

                var wrapper = node.ownerDocument.createElement('html2canvaswrapper');

                var parent = node.parentNode,

                    backupText = node.cloneNode(true);



                wrapper.appendChild(node.cloneNode(true));

                parent.replaceChild(wrapper, node);

                var bounds = transform ? offsetBounds(wrapper) : getBounds(wrapper);

                parent.replaceChild(backupText, wrapper);

                return bounds;

            };



            NodeParser.prototype.getRangeBounds = function (node, offset, length) {

                var range = this.range || (this.range = node.ownerDocument.createRange());

                range.setStart(node, offset);

                range.setEnd(node, offset + length);

                return range.getBoundingClientRect();

            };



            function ClearTransform() {}



            NodeParser.prototype.parse = function (stack) {

                // http://www.w3.org/TR/CSS21/visuren.html#z-index

                var negativeZindex = stack.contexts.filter(negativeZIndex); // 2. the child stacking contexts with negative stack levels (most negative first).

                var descendantElements = stack.children.filter(isElement);

                var descendantNonFloats = descendantElements.filter(not(isFloating));

                var nonInlineNonPositionedDescendants = descendantNonFloats.filter(not(isPositioned)).filter(not(inlineLevel)); // 3 the in-flow, non-inline-level, non-positioned descendants.

                var nonPositionedFloats = descendantElements.filter(not(isPositioned)).filter(isFloating); // 4. the non-positioned floats.

                var inFlow = descendantNonFloats.filter(not(isPositioned)).filter(inlineLevel); // 5. the in-flow, inline-level, non-positioned descendants, including inline tables and inline blocks.

                var stackLevel0 = stack.contexts.concat(descendantNonFloats.filter(isPositioned)).filter(zIndex0); // 6. the child stacking contexts with stack level 0 and the positioned descendants with stack level 0.

                var text = stack.children.filter(isTextNode).filter(hasText);

                var positiveZindex = stack.contexts.filter(positiveZIndex); // 7. the child stacking contexts with positive stack levels (least positive first).

                negativeZindex.concat(nonInlineNonPositionedDescendants).concat(nonPositionedFloats)

                    .concat(inFlow).concat(stackLevel0).concat(text).concat(positiveZindex).forEach(function (container) {

                        this.renderQueue.push(container);

                        if (isStackingContext(container)) {

                            this.parse(container);

                            this.renderQueue.push(new ClearTransform());

                        }

                    }, this);

            };



            NodeParser.prototype.paint = function (container) {

                try {

                    if (container instanceof ClearTransform) {

                        this.renderer.ctx.restore();

                    } else if (isTextNode(container)) {

                        if (isPseudoElement(container.parent)) {

                            container.parent.appendToDOM();

                        }

                        this.paintText(container);

                        if (isPseudoElement(container.parent)) {

                            container.parent.cleanDOM();

                        }

                    } else {

                        this.paintNode(container);

                    }

                } catch (e) {

                    log(e);

                    if (this.options.strict) {

                        throw e;

                    }

                }

            };



            NodeParser.prototype.paintNode = function (container) {

                if (isStackingContext(container)) {

                    this.renderer.setOpacity(container.opacity);

                    this.renderer.ctx.save();

                    if (container.hasTransform()) {

                        this.renderer.setTransform(container.parseTransform());

                    }

                }



                if (container.node.nodeName === "INPUT" && container.node.type === "checkbox") {

                    this.paintCheckbox(container);

                } else if (container.node.nodeName === "INPUT" && container.node.type === "radio") {

                    this.paintRadio(container);

                } else {

                    this.paintElement(container);

                }

            };



            NodeParser.prototype.paintElement = function (container) {

                var bounds = container.parseBounds();

                this.renderer.clip(container.backgroundClip, function () {

                    this.renderer.renderBackground(container, bounds, container.borders.borders.map(getWidth));

                }, this);



                this.renderer.clip(container.clip, function () {

                    this.renderer.renderBorders(container.borders.borders);

                }, this);



                this.renderer.clip(container.backgroundClip, function () {

                    switch (container.node.nodeName) {

                        case "svg":

                        case "IFRAME":

                            var imgContainer = this.images.get(container.node);

                            if (imgContainer) {

                                this.renderer.renderImage(container, bounds, container.borders, imgContainer);

                            } else {

                                log("Error loading <" + container.node.nodeName + ">", container.node);

                            }

                            break;

                        case "IMG":

                            var imageContainer = this.images.get(container.node.src);

                            if (imageContainer) {

                                this.renderer.renderImage(container, bounds, container.borders, imageContainer);

                            } else {

                                log("Error loading <img>", container.node.src);

                            }

                            break;

                        case "CANVAS":

                            this.renderer.renderImage(container, bounds, container.borders, {
                                image: container.node
                            });

                            break;

                        case "SELECT":

                        case "INPUT":

                        case "TEXTAREA":

                            this.paintFormValue(container);

                            break;

                    }

                }, this);

            };



            NodeParser.prototype.paintCheckbox = function (container) {

                var b = container.parseBounds();



                var size = Math.min(b.width, b.height);

                var bounds = {
                    width: size - 1,
                    height: size - 1,
                    top: b.top,
                    left: b.left
                };

                var r = [3, 3];

                var radius = [r, r, r, r];

                var borders = [1, 1, 1, 1].map(function (w) {

                    return {
                        color: new Color('#A5A5A5'),
                        width: w
                    };

                });



                var borderPoints = calculateCurvePoints(bounds, radius, borders);



                this.renderer.clip(container.backgroundClip, function () {

                    this.renderer.rectangle(bounds.left + 1, bounds.top + 1, bounds.width - 2, bounds.height - 2, new Color("#DEDEDE"));

                    this.renderer.renderBorders(calculateBorders(borders, bounds, borderPoints, radius));

                    if (container.node.checked) {

                        this.renderer.font(new Color('#424242'), 'normal', 'normal', 'bold', (size - 3) + "px", 'arial');

                        this.renderer.text("\u2714", bounds.left + size / 6, bounds.top + size - 1);

                    }

                }, this);

            };



            NodeParser.prototype.paintRadio = function (container) {

                var bounds = container.parseBounds();



                var size = Math.min(bounds.width, bounds.height) - 2;



                this.renderer.clip(container.backgroundClip, function () {

                    this.renderer.circleStroke(bounds.left + 1, bounds.top + 1, size, new Color('#DEDEDE'), 1, new Color('#A5A5A5'));

                    if (container.node.checked) {

                        this.renderer.circle(Math.ceil(bounds.left + size / 4) + 1, Math.ceil(bounds.top + size / 4) + 1, Math.floor(size / 2), new Color('#424242'));

                    }

                }, this);

            };



            NodeParser.prototype.paintFormValue = function (container) {

                var value = container.getValue();

                if (value.length > 0) {

                    var document = container.node.ownerDocument;

                    var wrapper = document.createElement('html2canvaswrapper');

                    var properties = ['lineHeight', 'textAlign', 'fontFamily', 'fontWeight', 'fontSize', 'color',

                        'paddingLeft', 'paddingTop', 'paddingRight', 'paddingBottom',

                        'width', 'height', 'borderLeftStyle', 'borderTopStyle', 'borderLeftWidth', 'borderTopWidth',

                        'boxSizing', 'whiteSpace', 'wordWrap'
                    ];



                    properties.forEach(function (property) {

                        try {

                            wrapper.style[property] = container.css(property);

                        } catch (e) {

                            // Older IE has issues with "border"

                            log("html2canvas: Parse: Exception caught in renderFormValue: " + e.message);

                        }

                    });

                    var bounds = container.parseBounds();

                    wrapper.style.position = "fixed";

                    wrapper.style.left = bounds.left + "px";

                    wrapper.style.top = bounds.top + "px";

                    wrapper.textContent = value;

                    document.body.appendChild(wrapper);

                    this.paintText(new TextContainer(wrapper.firstChild, container));

                    document.body.removeChild(wrapper);

                }

            };



            NodeParser.prototype.paintText = function (container) {

                container.applyTextTransform();

                var characters = punycode.ucs2.decode(container.node.data);

                var textList = (!this.options.letterRendering || noLetterSpacing(container)) && !hasUnicode(container.node.data) ? getWords(characters) : characters.map(function (character) {

                    return punycode.ucs2.encode([character]);

                });



                var weight = container.parent.fontWeight();

                var size = container.parent.css('fontSize');

                var family = container.parent.css('fontFamily');

                var shadows = container.parent.parseTextShadows();



                this.renderer.font(container.parent.color('color'), container.parent.css('fontStyle'), container.parent.css('fontVariant'), weight, size, family);

                if (shadows.length) {

                    // TODO: support multiple text shadows

                    this.renderer.fontShadow(shadows[0].color, shadows[0].offsetX, shadows[0].offsetY, shadows[0].blur);

                } else {

                    this.renderer.clearShadow();

                }



                this.renderer.clip(container.parent.clip, function () {

                    textList.map(this.parseTextBounds(container), this).forEach(function (bounds, index) {

                        if (bounds) {

                            this.renderer.text(textList[index], bounds.left, bounds.bottom);

                            this.renderTextDecoration(container.parent, bounds, this.fontMetrics.getMetrics(family, size));

                        }

                    }, this);

                }, this);

            };



            NodeParser.prototype.renderTextDecoration = function (container, bounds, metrics) {

                switch (container.css("textDecoration").split(" ")[0]) {

                    case "underline":

                        // Draws a line at the baseline of the font

                        // TODO As some browsers display the line as more than 1px if the font-size is big, need to take that into account both in position and size

                        this.renderer.rectangle(bounds.left, Math.round(bounds.top + metrics.baseline + metrics.lineWidth), bounds.width, 1, container.color("color"));

                        break;

                    case "overline":

                        this.renderer.rectangle(bounds.left, Math.round(bounds.top), bounds.width, 1, container.color("color"));

                        break;

                    case "line-through":

                        // TODO try and find exact position for line-through

                        this.renderer.rectangle(bounds.left, Math.ceil(bounds.top + metrics.middle + metrics.lineWidth), bounds.width, 1, container.color("color"));

                        break;

                }

            };



            var borderColorTransforms = {

                inset: [

                    ["darken", 0.60],

                    ["darken", 0.10],

                    ["darken", 0.10],

                    ["darken", 0.60]

                ]

            };



            NodeParser.prototype.parseBorders = function (container) {

                var nodeBounds = container.parseBounds();

                var radius = getBorderRadiusData(container);

                var borders = ["Top", "Right", "Bottom", "Left"].map(function (side, index) {

                    var style = container.css('border' + side + 'Style');

                    var color = container.color('border' + side + 'Color');

                    if (style === "inset" && color.isBlack()) {

                        color = new Color([255, 255, 255, color.a]); // this is wrong, but

                    }

                    var colorTransform = borderColorTransforms[style] ? borderColorTransforms[style][index] : null;

                    return {

                        width: container.cssInt('border' + side + 'Width'),

                        color: colorTransform ? color[colorTransform[0]](colorTransform[1]) : color,

                        args: null

                    };

                });

                var borderPoints = calculateCurvePoints(nodeBounds, radius, borders);



                return {

                    clip: this.parseBackgroundClip(container, borderPoints, borders, radius, nodeBounds),

                    borders: calculateBorders(borders, nodeBounds, borderPoints, radius)

                };

            };



            function calculateBorders(borders, nodeBounds, borderPoints, radius) {

                return borders.map(function (border, borderSide) {

                    if (border.width > 0) {

                        var bx = nodeBounds.left;

                        var by = nodeBounds.top;

                        var bw = nodeBounds.width;

                        var bh = nodeBounds.height - (borders[2].width);



                        switch (borderSide) {

                            case 0:

                                // top border

                                bh = borders[0].width;

                                border.args = drawSide({

                                        c1: [bx, by],

                                        c2: [bx + bw, by],

                                        c3: [bx + bw - borders[1].width, by + bh],

                                        c4: [bx + borders[3].width, by + bh]

                                    }, radius[0], radius[1],

                                    borderPoints.topLeftOuter, borderPoints.topLeftInner, borderPoints.topRightOuter, borderPoints.topRightInner);

                                break;

                            case 1:

                                // right border

                                bx = nodeBounds.left + nodeBounds.width - (borders[1].width);

                                bw = borders[1].width;



                                border.args = drawSide({

                                        c1: [bx + bw, by],

                                        c2: [bx + bw, by + bh + borders[2].width],

                                        c3: [bx, by + bh],

                                        c4: [bx, by + borders[0].width]

                                    }, radius[1], radius[2],

                                    borderPoints.topRightOuter, borderPoints.topRightInner, borderPoints.bottomRightOuter, borderPoints.bottomRightInner);

                                break;

                            case 2:

                                // bottom border

                                by = (by + nodeBounds.height) - (borders[2].width);

                                bh = borders[2].width;

                                border.args = drawSide({

                                        c1: [bx + bw, by + bh],

                                        c2: [bx, by + bh],

                                        c3: [bx + borders[3].width, by],

                                        c4: [bx + bw - borders[3].width, by]

                                    }, radius[2], radius[3],

                                    borderPoints.bottomRightOuter, borderPoints.bottomRightInner, borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner);

                                break;

                            case 3:

                                // left border

                                bw = borders[3].width;

                                border.args = drawSide({

                                        c1: [bx, by + bh + borders[2].width],

                                        c2: [bx, by],

                                        c3: [bx + bw, by + borders[0].width],

                                        c4: [bx + bw, by + bh]

                                    }, radius[3], radius[0],

                                    borderPoints.bottomLeftOuter, borderPoints.bottomLeftInner, borderPoints.topLeftOuter, borderPoints.topLeftInner);

                                break;

                        }

                    }

                    return border;

                });

            }



            NodeParser.prototype.parseBackgroundClip = function (container, borderPoints, borders, radius, bounds) {

                var backgroundClip = container.css('backgroundClip'),

                    borderArgs = [];



                switch (backgroundClip) {

                    case "content-box":

                    case "padding-box":

                        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftInner, borderPoints.topRightInner, bounds.left + borders[3].width, bounds.top + borders[0].width);

                        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightInner, borderPoints.bottomRightInner, bounds.left + bounds.width - borders[1].width, bounds.top + borders[0].width);

                        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightInner, borderPoints.bottomLeftInner, bounds.left + bounds.width - borders[1].width, bounds.top + bounds.height - borders[2].width);

                        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftInner, borderPoints.topLeftInner, bounds.left + borders[3].width, bounds.top + bounds.height - borders[2].width);

                        break;



                    default:

                        parseCorner(borderArgs, radius[0], radius[1], borderPoints.topLeftOuter, borderPoints.topRightOuter, bounds.left, bounds.top);

                        parseCorner(borderArgs, radius[1], radius[2], borderPoints.topRightOuter, borderPoints.bottomRightOuter, bounds.left + bounds.width, bounds.top);

                        parseCorner(borderArgs, radius[2], radius[3], borderPoints.bottomRightOuter, borderPoints.bottomLeftOuter, bounds.left + bounds.width, bounds.top + bounds.height);

                        parseCorner(borderArgs, radius[3], radius[0], borderPoints.bottomLeftOuter, borderPoints.topLeftOuter, bounds.left, bounds.top + bounds.height);

                        break;

                }



                return borderArgs;

            };



            function getCurvePoints(x, y, r1, r2) {

                var kappa = 4 * ((Math.sqrt(2) - 1) / 3);

                var ox = (r1) * kappa, // control point offset horizontal

                    oy = (r2) * kappa, // control point offset vertical

                    xm = x + r1, // x-middle

                    ym = y + r2; // y-middle

                return {

                    topLeft: bezierCurve({
                        x: x,
                        y: ym
                    }, {
                        x: x,
                        y: ym - oy
                    }, {
                        x: xm - ox,
                        y: y
                    }, {
                        x: xm,
                        y: y
                    }),

                    topRight: bezierCurve({
                        x: x,
                        y: y
                    }, {
                        x: x + ox,
                        y: y
                    }, {
                        x: xm,
                        y: ym - oy
                    }, {
                        x: xm,
                        y: ym
                    }),

                    bottomRight: bezierCurve({
                        x: xm,
                        y: y
                    }, {
                        x: xm,
                        y: y + oy
                    }, {
                        x: x + ox,
                        y: ym
                    }, {
                        x: x,
                        y: ym
                    }),

                    bottomLeft: bezierCurve({
                        x: xm,
                        y: ym
                    }, {
                        x: xm - ox,
                        y: ym
                    }, {
                        x: x,
                        y: y + oy
                    }, {
                        x: x,
                        y: y
                    })

                };

            }



            function calculateCurvePoints(bounds, borderRadius, borders) {

                var x = bounds.left,

                    y = bounds.top,

                    width = bounds.width,

                    height = bounds.height,



                    tlh = borderRadius[0][0] < width / 2 ? borderRadius[0][0] : width / 2,

                    tlv = borderRadius[0][1] < height / 2 ? borderRadius[0][1] : height / 2,

                    trh = borderRadius[1][0] < width / 2 ? borderRadius[1][0] : width / 2,

                    trv = borderRadius[1][1] < height / 2 ? borderRadius[1][1] : height / 2,

                    brh = borderRadius[2][0] < width / 2 ? borderRadius[2][0] : width / 2,

                    brv = borderRadius[2][1] < height / 2 ? borderRadius[2][1] : height / 2,

                    blh = borderRadius[3][0] < width / 2 ? borderRadius[3][0] : width / 2,

                    blv = borderRadius[3][1] < height / 2 ? borderRadius[3][1] : height / 2;



                var topWidth = width - trh,

                    rightHeight = height - brv,

                    bottomWidth = width - brh,

                    leftHeight = height - blv;



                return {

                    topLeftOuter: getCurvePoints(x, y, tlh, tlv).topLeft.subdivide(0.5),

                    topLeftInner: getCurvePoints(x + borders[3].width, y + borders[0].width, Math.max(0, tlh - borders[3].width), Math.max(0, tlv - borders[0].width)).topLeft.subdivide(0.5),

                    topRightOuter: getCurvePoints(x + topWidth, y, trh, trv).topRight.subdivide(0.5),

                    topRightInner: getCurvePoints(x + Math.min(topWidth, width + borders[3].width), y + borders[0].width, (topWidth > width + borders[3].width) ? 0 : trh - borders[3].width, trv - borders[0].width).topRight.subdivide(0.5),

                    bottomRightOuter: getCurvePoints(x + bottomWidth, y + rightHeight, brh, brv).bottomRight.subdivide(0.5),

                    bottomRightInner: getCurvePoints(x + Math.min(bottomWidth, width - borders[3].width), y + Math.min(rightHeight, height + borders[0].width), Math.max(0, brh - borders[1].width), brv - borders[2].width).bottomRight.subdivide(0.5),

                    bottomLeftOuter: getCurvePoints(x, y + leftHeight, blh, blv).bottomLeft.subdivide(0.5),

                    bottomLeftInner: getCurvePoints(x + borders[3].width, y + leftHeight, Math.max(0, blh - borders[3].width), blv - borders[2].width).bottomLeft.subdivide(0.5)

                };

            }



            function bezierCurve(start, startControl, endControl, end) {

                var lerp = function (a, b, t) {

                    return {

                        x: a.x + (b.x - a.x) * t,

                        y: a.y + (b.y - a.y) * t

                    };

                };



                return {

                    start: start,

                    startControl: startControl,

                    endControl: endControl,

                    end: end,

                    subdivide: function (t) {

                        var ab = lerp(start, startControl, t),

                            bc = lerp(startControl, endControl, t),

                            cd = lerp(endControl, end, t),

                            abbc = lerp(ab, bc, t),

                            bccd = lerp(bc, cd, t),

                            dest = lerp(abbc, bccd, t);

                        return [bezierCurve(start, ab, abbc, dest), bezierCurve(dest, bccd, cd, end)];

                    },

                    curveTo: function (borderArgs) {

                        borderArgs.push(["bezierCurve", startControl.x, startControl.y, endControl.x, endControl.y, end.x, end.y]);

                    },

                    curveToReversed: function (borderArgs) {

                        borderArgs.push(["bezierCurve", endControl.x, endControl.y, startControl.x, startControl.y, start.x, start.y]);

                    }

                };

            }



            function drawSide(borderData, radius1, radius2, outer1, inner1, outer2, inner2) {

                var borderArgs = [];



                if (radius1[0] > 0 || radius1[1] > 0) {

                    borderArgs.push(["line", outer1[1].start.x, outer1[1].start.y]);

                    outer1[1].curveTo(borderArgs);

                } else {

                    borderArgs.push(["line", borderData.c1[0], borderData.c1[1]]);

                }



                if (radius2[0] > 0 || radius2[1] > 0) {

                    borderArgs.push(["line", outer2[0].start.x, outer2[0].start.y]);

                    outer2[0].curveTo(borderArgs);

                    borderArgs.push(["line", inner2[0].end.x, inner2[0].end.y]);

                    inner2[0].curveToReversed(borderArgs);

                } else {

                    borderArgs.push(["line", borderData.c2[0], borderData.c2[1]]);

                    borderArgs.push(["line", borderData.c3[0], borderData.c3[1]]);

                }



                if (radius1[0] > 0 || radius1[1] > 0) {

                    borderArgs.push(["line", inner1[1].end.x, inner1[1].end.y]);

                    inner1[1].curveToReversed(borderArgs);

                } else {

                    borderArgs.push(["line", borderData.c4[0], borderData.c4[1]]);

                }



                return borderArgs;

            }



            function parseCorner(borderArgs, radius1, radius2, corner1, corner2, x, y) {

                if (radius1[0] > 0 || radius1[1] > 0) {

                    borderArgs.push(["line", corner1[0].start.x, corner1[0].start.y]);

                    corner1[0].curveTo(borderArgs);

                    corner1[1].curveTo(borderArgs);

                } else {

                    borderArgs.push(["line", x, y]);

                }



                if (radius2[0] > 0 || radius2[1] > 0) {

                    borderArgs.push(["line", corner2[0].start.x, corner2[0].start.y]);

                }

            }



            function negativeZIndex(container) {

                return container.cssInt("zIndex") < 0;

            }



            function positiveZIndex(container) {

                return container.cssInt("zIndex") > 0;

            }



            function zIndex0(container) {

                return container.cssInt("zIndex") === 0;

            }



            function inlineLevel(container) {

                return ["inline", "inline-block", "inline-table"].indexOf(container.css("display")) !== -1;

            }



            function isStackingContext(container) {

                return (container instanceof StackingContext);

            }



            function hasText(container) {

                return container.node.data.trim().length > 0;

            }



            function noLetterSpacing(container) {

                return (/^(normal|none|0px)$/.test(container.parent.css("letterSpacing")));

            }



            function getBorderRadiusData(container) {

                return ["TopLeft", "TopRight", "BottomRight", "BottomLeft"].map(function (side) {

                    var value = container.css('border' + side + 'Radius');

                    var arr = value.split(" ");

                    if (arr.length <= 1) {

                        arr[1] = arr[0];

                    }

                    return arr.map(asInt);

                });

            }



            function renderableNode(node) {

                return (node.nodeType === Node.TEXT_NODE || node.nodeType === Node.ELEMENT_NODE);

            }



            function isPositionedForStacking(container) {

                var position = container.css("position");

                var zIndex = (["absolute", "relative", "fixed"].indexOf(position) !== -1) ? container.css("zIndex") : "auto";

                return zIndex !== "auto";

            }



            function isPositioned(container) {

                return container.css("position") !== "static";

            }



            function isFloating(container) {

                return container.css("float") !== "none";

            }



            function isInlineBlock(container) {

                return ["inline-block", "inline-table"].indexOf(container.css("display")) !== -1;

            }



            function not(callback) {

                var context = this;

                return function () {

                    return !callback.apply(context, arguments);

                };

            }



            function isElement(container) {

                return container.node.nodeType === Node.ELEMENT_NODE;

            }



            function isPseudoElement(container) {

                return container.isPseudoElement === true;

            }



            function isTextNode(container) {

                return container.node.nodeType === Node.TEXT_NODE;

            }



            function zIndexSort(contexts) {

                return function (a, b) {

                    return (a.cssInt("zIndex") + (contexts.indexOf(a) / contexts.length)) - (b.cssInt("zIndex") + (contexts.indexOf(b) / contexts.length));

                };

            }



            function hasOpacity(container) {

                return container.getOpacity() < 1;

            }



            function asInt(value) {

                return parseInt(value, 10);

            }



            function getWidth(border) {

                return border.width;

            }



            function nonIgnoredElement(nodeContainer) {

                return (nodeContainer.node.nodeType !== Node.ELEMENT_NODE || ["SCRIPT", "HEAD", "TITLE", "OBJECT", "BR", "OPTION"].indexOf(nodeContainer.node.nodeName) === -1);

            }



            function flatten(arrays) {

                return [].concat.apply([], arrays);

            }



            function stripQuotes(content) {

                var first = content.substr(0, 1);

                return (first === content.substr(content.length - 1) && first.match(/'|"/)) ? content.substr(1, content.length - 2) : content;

            }



            function getWords(characters) {

                var words = [],
                    i = 0,
                    onWordBoundary = false,
                    word;

                while (characters.length) {

                    if (isWordBoundary(characters[i]) === onWordBoundary) {

                        word = characters.splice(0, i);

                        if (word.length) {

                            words.push(punycode.ucs2.encode(word));

                        }

                        onWordBoundary = !onWordBoundary;

                        i = 0;

                    } else {

                        i++;

                    }



                    if (i >= characters.length) {

                        word = characters.splice(0, i);

                        if (word.length) {

                            words.push(punycode.ucs2.encode(word));

                        }

                    }

                }

                return words;

            }



            function isWordBoundary(characterCode) {

                return [

                    32, // <space>

                    13, // \r

                    10, // \n

                    9, // \t

                    45 // -

                ].indexOf(characterCode) !== -1;

            }



            function hasUnicode(string) {

                return (/[^\u0000-\u00ff]/).test(string);

            }



            module.exports = NodeParser;



        }, {
            "./color": 3,
            "./fontmetrics": 7,
            "./log": 13,
            "./nodecontainer": 14,
            "./pseudoelementcontainer": 18,
            "./stackingcontext": 21,
            "./textcontainer": 25,
            "./utils": 26,
            "punycode": 1
        }],
        16: [function (_dereq_, module, exports) {

            var XHR = _dereq_('./xhr');

            var utils = _dereq_('./utils');

            var log = _dereq_('./log');

            var createWindowClone = _dereq_('./clone');

            var decode64 = utils.decode64;



            function Proxy(src, proxyUrl, document) {

                var supportsCORS = ('withCredentials' in new XMLHttpRequest());

                if (!proxyUrl) {

                    return Promise.reject("No proxy configured");

                }

                var callback = createCallback(supportsCORS);

                var url = createProxyUrl(proxyUrl, src, callback);



                return supportsCORS ? XHR(url) : (jsonp(document, url, callback).then(function (response) {

                    return decode64(response.content);

                }));

            }

            var proxyCount = 0;



            function ProxyURL(src, proxyUrl, document) {

                var supportsCORSImage = ('crossOrigin' in new Image());

                var callback = createCallback(supportsCORSImage);

                var url = createProxyUrl(proxyUrl, src, callback);

                return (supportsCORSImage ? Promise.resolve(url) : jsonp(document, url, callback).then(function (response) {

                    return "data:" + response.type + ";base64," + response.content;

                }));

            }



            function jsonp(document, url, callback) {

                return new Promise(function (resolve, reject) {

                    var s = document.createElement("script");

                    var cleanup = function () {

                        delete window.html2canvas.proxy[callback];

                        document.body.removeChild(s);

                    };

                    window.html2canvas.proxy[callback] = function (response) {

                        cleanup();

                        resolve(response);

                    };

                    s.src = url;

                    s.onerror = function (e) {

                        cleanup();

                        reject(e);

                    };

                    document.body.appendChild(s);

                });

            }



            function createCallback(useCORS) {

                return !useCORS ? "html2canvas_" + Date.now() + "_" + (++proxyCount) + "_" + Math.round(Math.random() * 100000) : "";

            }



            function createProxyUrl(proxyUrl, src, callback) {

                return proxyUrl + "?url=" + encodeURIComponent(src) + (callback.length ? "&callback=html2canvas.proxy." + callback : "");

            }



            function documentFromHTML(src) {

                return function (html) {

                    var parser = new DOMParser(),
                        doc;

                    try {

                        doc = parser.parseFromString(html, "text/html");

                    } catch (e) {

                        log("DOMParser not supported, falling back to createHTMLDocument");

                        doc = document.implementation.createHTMLDocument("");

                        try {

                            doc.open();

                            doc.write(html);

                            doc.close();

                        } catch (ee) {

                            log("createHTMLDocument write not supported, falling back to document.body.innerHTML");

                            doc.body.innerHTML = html; // ie9 doesnt support writing to documentElement

                        }

                    }



                    var b = doc.querySelector("base");

                    if (!b || !b.href.host) {

                        var base = doc.createElement("base");

                        base.href = src;

                        doc.head.insertBefore(base, doc.head.firstChild);

                    }



                    return doc;

                };

            }



            function loadUrlDocument(src, proxy, document, width, height, options) {

                return new Proxy(src, proxy, window.document).then(documentFromHTML(src)).then(function (doc) {

                    return createWindowClone(doc, document, width, height, options, 0, 0);

                });

            }



            exports.Proxy = Proxy;

            exports.ProxyURL = ProxyURL;

            exports.loadUrlDocument = loadUrlDocument;



        }, {
            "./clone": 2,
            "./log": 13,
            "./utils": 26,
            "./xhr": 28
        }],
        17: [function (_dereq_, module, exports) {

            var ProxyURL = _dereq_('./proxy').ProxyURL;



            function ProxyImageContainer(src, proxy) {

                var link = document.createElement("a");

                link.href = src;

                src = link.href;

                this.src = src;

                this.image = new Image();

                var self = this;

                this.promise = new Promise(function (resolve, reject) {

                    self.image.crossOrigin = "Anonymous";

                    self.image.onload = resolve;

                    self.image.onerror = reject;



                    new ProxyURL(src, proxy, document).then(function (url) {

                        self.image.src = url;

                    })['catch'](reject);

                });

            }



            module.exports = ProxyImageContainer;



        }, {
            "./proxy": 16
        }],
        18: [function (_dereq_, module, exports) {

            var NodeContainer = _dereq_('./nodecontainer');



            function PseudoElementContainer(node, parent, type) {

                NodeContainer.call(this, node, parent);

                this.isPseudoElement = true;

                this.before = type === ":before";

            }



            PseudoElementContainer.prototype.cloneTo = function (stack) {

                PseudoElementContainer.prototype.cloneTo.call(this, stack);

                stack.isPseudoElement = true;

                stack.before = this.before;

            };



            PseudoElementContainer.prototype = Object.create(NodeContainer.prototype);



            PseudoElementContainer.prototype.appendToDOM = function () {

                if (this.before) {

                    this.parent.node.insertBefore(this.node, this.parent.node.firstChild);

                } else {

                    this.parent.node.appendChild(this.node);

                }

                this.parent.node.className += " " + this.getHideClass();

            };



            PseudoElementContainer.prototype.cleanDOM = function () {

                this.node.parentNode.removeChild(this.node);

                this.parent.node.className = this.parent.node.className.replace(this.getHideClass(), "");

            };



            PseudoElementContainer.prototype.getHideClass = function () {

                return this["PSEUDO_HIDE_ELEMENT_CLASS_" + (this.before ? "BEFORE" : "AFTER")];

            };



            PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_BEFORE = "___html2canvas___pseudoelement_before";

            PseudoElementContainer.prototype.PSEUDO_HIDE_ELEMENT_CLASS_AFTER = "___html2canvas___pseudoelement_after";



            module.exports = PseudoElementContainer;



        }, {
            "./nodecontainer": 14
        }],
        19: [function (_dereq_, module, exports) {

            var log = _dereq_('./log');



            function Renderer(width, height, images, options, document) {

                this.width = width;

                this.height = height;

                this.images = images;

                this.options = options;

                this.document = document;

            }



            Renderer.prototype.renderImage = function (container, bounds, borderData, imageContainer) {

                var paddingLeft = container.cssInt('paddingLeft'),

                    paddingTop = container.cssInt('paddingTop'),

                    paddingRight = container.cssInt('paddingRight'),

                    paddingBottom = container.cssInt('paddingBottom'),

                    borders = borderData.borders;



                var width = bounds.width - (borders[1].width + borders[3].width + paddingLeft + paddingRight);

                var height = bounds.height - (borders[0].width + borders[2].width + paddingTop + paddingBottom);

                this.drawImage(

                    imageContainer,

                    0,

                    0,

                    imageContainer.image.width || width,

                    imageContainer.image.height || height,

                    bounds.left + paddingLeft + borders[3].width,

                    bounds.top + paddingTop + borders[0].width,

                    width,

                    height

                );

            };



            Renderer.prototype.renderBackground = function (container, bounds, borderData) {

                if (bounds.height > 0 && bounds.width > 0) {

                    this.renderBackgroundColor(container, bounds);

                    this.renderBackgroundImage(container, bounds, borderData);

                }

            };



            Renderer.prototype.renderBackgroundColor = function (container, bounds) {

                var color = container.color("backgroundColor");

                if (!color.isTransparent()) {

                    this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, color);

                }

            };



            Renderer.prototype.renderBorders = function (borders) {

                borders.forEach(this.renderBorder, this);

            };



            Renderer.prototype.renderBorder = function (data) {

                if (!data.color.isTransparent() && data.args !== null) {

                    this.drawShape(data.args, data.color);

                }

            };



            Renderer.prototype.renderBackgroundImage = function (container, bounds, borderData) {

                var backgroundImages = container.parseBackgroundImages();

                backgroundImages.reverse().forEach(function (backgroundImage, index, arr) {

                    switch (backgroundImage.method) {

                        case "url":

                            var image = this.images.get(backgroundImage.args[0]);

                            if (image) {

                                this.renderBackgroundRepeating(container, bounds, image, arr.length - (index + 1), borderData);

                            } else {

                                log("Error loading background-image", backgroundImage.args[0]);

                            }

                            break;

                        case "linear-gradient":

                        case "gradient":

                            var gradientImage = this.images.get(backgroundImage.value);

                            if (gradientImage) {

                                this.renderBackgroundGradient(gradientImage, bounds, borderData);

                            } else {

                                log("Error loading background-image", backgroundImage.args[0]);

                            }

                            break;

                        case "none":

                            break;

                        default:

                            log("Unknown background-image type", backgroundImage.args[0]);

                    }

                }, this);

            };



            Renderer.prototype.renderBackgroundRepeating = function (container, bounds, imageContainer, index, borderData) {

                var size = container.parseBackgroundSize(bounds, imageContainer.image, index);

                var position = container.parseBackgroundPosition(bounds, imageContainer.image, index, size);

                var repeat = container.parseBackgroundRepeat(index);

                switch (repeat) {

                    case "repeat-x":

                    case "repeat no-repeat":

                        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + borderData[3], bounds.top + position.top + borderData[0], 99999, size.height, borderData);

                        break;

                    case "repeat-y":

                    case "no-repeat repeat":

                        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + borderData[0], size.width, 99999, borderData);

                        break;

                    case "no-repeat":

                        this.backgroundRepeatShape(imageContainer, position, size, bounds, bounds.left + position.left + borderData[3], bounds.top + position.top + borderData[0], size.width, size.height, borderData);

                        break;

                    default:

                        this.renderBackgroundRepeat(imageContainer, position, size, {
                            top: bounds.top,
                            left: bounds.left
                        }, borderData[3], borderData[0]);

                        break;

                }

            };



            module.exports = Renderer;



        }, {
            "./log": 13
        }],
        20: [function (_dereq_, module, exports) {

            var Renderer = _dereq_('../renderer');

            var LinearGradientContainer = _dereq_('../lineargradientcontainer');

            var log = _dereq_('../log');



            function CanvasRenderer(width, height) {

                Renderer.apply(this, arguments);

                this.canvas = this.options.canvas || this.document.createElement("canvas");

                if (!this.options.canvas) {

                    this.canvas.width = width;

                    this.canvas.height = height;

                }

                this.ctx = this.canvas.getContext("2d");

                this.taintCtx = this.document.createElement("canvas").getContext("2d");

                this.ctx.textBaseline = "bottom";

                this.variables = {};

                log("Initialized CanvasRenderer with size", width, "x", height);

            }



            CanvasRenderer.prototype = Object.create(Renderer.prototype);



            CanvasRenderer.prototype.setFillStyle = function (fillStyle) {

                this.ctx.fillStyle = typeof (fillStyle) === "object" && !!fillStyle.isColor ? fillStyle.toString() : fillStyle;

                return this.ctx;

            };



            CanvasRenderer.prototype.rectangle = function (left, top, width, height, color) {

                this.setFillStyle(color).fillRect(left, top, width, height);

            };



            CanvasRenderer.prototype.circle = function (left, top, size, color) {

                this.setFillStyle(color);

                this.ctx.beginPath();

                this.ctx.arc(left + size / 2, top + size / 2, size / 2, 0, Math.PI * 2, true);

                this.ctx.closePath();

                this.ctx.fill();

            };



            CanvasRenderer.prototype.circleStroke = function (left, top, size, color, stroke, strokeColor) {

                this.circle(left, top, size, color);

                this.ctx.strokeStyle = strokeColor.toString();

                this.ctx.stroke();

            };



            CanvasRenderer.prototype.drawShape = function (shape, color) {

                this.shape(shape);

                this.setFillStyle(color).fill();

            };



            CanvasRenderer.prototype.taints = function (imageContainer) {

                if (imageContainer.tainted === null) {

                    this.taintCtx.drawImage(imageContainer.image, 0, 0);

                    try {

                        this.taintCtx.getImageData(0, 0, 1, 1);

                        imageContainer.tainted = false;

                    } catch (e) {

                        this.taintCtx = document.createElement("canvas").getContext("2d");

                        imageContainer.tainted = true;

                    }

                }



                return imageContainer.tainted;

            };



            CanvasRenderer.prototype.drawImage = function (imageContainer, sx, sy, sw, sh, dx, dy, dw, dh) {

                if (!this.taints(imageContainer) || this.options.allowTaint) {

                    this.ctx.drawImage(imageContainer.image, sx, sy, sw, sh, dx, dy, dw, dh);

                }

            };



            CanvasRenderer.prototype.clip = function (shapes, callback, context) {

                this.ctx.save();

                shapes.filter(hasEntries).forEach(function (shape) {

                    this.shape(shape).clip();

                }, this);

                callback.call(context);

                this.ctx.restore();

            };



            CanvasRenderer.prototype.shape = function (shape) {

                this.ctx.beginPath();

                shape.forEach(function (point, index) {

                    if (point[0] === "rect") {

                        this.ctx.rect.apply(this.ctx, point.slice(1));

                    } else {

                        this.ctx[(index === 0) ? "moveTo" : point[0] + "To"].apply(this.ctx, point.slice(1));

                    }

                }, this);

                this.ctx.closePath();

                return this.ctx;

            };



            CanvasRenderer.prototype.font = function (color, style, variant, weight, size, family) {

                this.setFillStyle(color).font = [style, variant, weight, size, family].join(" ").split(",")[0];

            };



            CanvasRenderer.prototype.fontShadow = function (color, offsetX, offsetY, blur) {

                this.setVariable("shadowColor", color.toString())

                    .setVariable("shadowOffsetY", offsetX)

                    .setVariable("shadowOffsetX", offsetY)

                    .setVariable("shadowBlur", blur);

            };



            CanvasRenderer.prototype.clearShadow = function () {

                this.setVariable("shadowColor", "rgba(0,0,0,0)");

            };



            CanvasRenderer.prototype.setOpacity = function (opacity) {

                this.ctx.globalAlpha = opacity;

            };



            CanvasRenderer.prototype.setTransform = function (transform) {

                this.ctx.translate(transform.origin[0], transform.origin[1]);

                this.ctx.transform.apply(this.ctx, transform.matrix);

                this.ctx.translate(-transform.origin[0], -transform.origin[1]);

            };



            CanvasRenderer.prototype.setVariable = function (property, value) {

                if (this.variables[property] !== value) {

                    this.variables[property] = this.ctx[property] = value;

                }



                return this;

            };



            CanvasRenderer.prototype.text = function (text, left, bottom) {

                this.ctx.fillText(text, left, bottom);

            };



            CanvasRenderer.prototype.backgroundRepeatShape = function (imageContainer, backgroundPosition, size, bounds, left, top, width, height, borderData) {

                var shape = [

                    ["line", Math.round(left), Math.round(top)],

                    ["line", Math.round(left + width), Math.round(top)],

                    ["line", Math.round(left + width), Math.round(height + top)],

                    ["line", Math.round(left), Math.round(height + top)]

                ];

                this.clip([shape], function () {

                    this.renderBackgroundRepeat(imageContainer, backgroundPosition, size, bounds, borderData[3], borderData[0]);

                }, this);

            };



            CanvasRenderer.prototype.renderBackgroundRepeat = function (imageContainer, backgroundPosition, size, bounds, borderLeft, borderTop) {

                var offsetX = Math.round(bounds.left + backgroundPosition.left + borderLeft),
                    offsetY = Math.round(bounds.top + backgroundPosition.top + borderTop);

                this.setFillStyle(this.ctx.createPattern(this.resizeImage(imageContainer, size), "repeat"));

                this.ctx.translate(offsetX, offsetY);

                this.ctx.fill();

                this.ctx.translate(-offsetX, -offsetY);

            };



            CanvasRenderer.prototype.renderBackgroundGradient = function (gradientImage, bounds) {

                if (gradientImage instanceof LinearGradientContainer) {

                    var gradient = this.ctx.createLinearGradient(

                        bounds.left + bounds.width * gradientImage.x0,

                        bounds.top + bounds.height * gradientImage.y0,

                        bounds.left + bounds.width * gradientImage.x1,

                        bounds.top + bounds.height * gradientImage.y1);

                    gradientImage.colorStops.forEach(function (colorStop) {

                        gradient.addColorStop(colorStop.stop, colorStop.color.toString());

                    });

                    this.rectangle(bounds.left, bounds.top, bounds.width, bounds.height, gradient);

                }

            };



            CanvasRenderer.prototype.resizeImage = function (imageContainer, size) {

                var image = imageContainer.image;

                if (image.width === size.width && image.height === size.height) {

                    return image;

                }



                var ctx, canvas = document.createElement('canvas');

                canvas.width = size.width;

                canvas.height = size.height;

                ctx = canvas.getContext("2d");

                ctx.drawImage(image, 0, 0, image.width, image.height, 0, 0, size.width, size.height);

                return canvas;

            };



            function hasEntries(array) {

                return array.length > 0;

            }



            module.exports = CanvasRenderer;



        }, {
            "../lineargradientcontainer": 12,
            "../log": 13,
            "../renderer": 19
        }],
        21: [function (_dereq_, module, exports) {

            var NodeContainer = _dereq_('./nodecontainer');



            function StackingContext(hasOwnStacking, opacity, element, parent) {

                NodeContainer.call(this, element, parent);

                this.ownStacking = hasOwnStacking;

                this.contexts = [];

                this.children = [];

                this.opacity = (this.parent ? this.parent.stack.opacity : 1) * opacity;

            }



            StackingContext.prototype = Object.create(NodeContainer.prototype);



            StackingContext.prototype.getParentStack = function (context) {

                var parentStack = (this.parent) ? this.parent.stack : null;

                return parentStack ? (parentStack.ownStacking ? parentStack : parentStack.getParentStack(context)) : context.stack;

            };



            module.exports = StackingContext;



        }, {
            "./nodecontainer": 14
        }],
        22: [function (_dereq_, module, exports) {

            function Support(document) {

                this.rangeBounds = this.testRangeBounds(document);

                this.cors = this.testCORS();

                this.svg = this.testSVG();

            }



            Support.prototype.testRangeBounds = function (document) {

                var range, testElement, rangeBounds, rangeHeight, support = false;



                if (document.createRange) {

                    range = document.createRange();

                    if (range.getBoundingClientRect) {

                        testElement = document.createElement('boundtest');

                        testElement.style.height = "123px";

                        testElement.style.display = "block";

                        document.body.appendChild(testElement);



                        range.selectNode(testElement);

                        rangeBounds = range.getBoundingClientRect();

                        rangeHeight = rangeBounds.height;



                        if (rangeHeight === 123) {

                            support = true;

                        }

                        document.body.removeChild(testElement);

                    }

                }



                return support;

            };



            Support.prototype.testCORS = function () {

                return typeof ((new Image()).crossOrigin) !== "undefined";

            };



            Support.prototype.testSVG = function () {

                var img = new Image();

                var canvas = document.createElement("canvas");

                var ctx = canvas.getContext("2d");

                img.src = "data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg'></svg>";



                try {

                    ctx.drawImage(img, 0, 0);

                    canvas.toDataURL();

                } catch (e) {

                    return false;

                }

                return true;

            };



            module.exports = Support;



        }, {}],
        23: [function (_dereq_, module, exports) {

            var XHR = _dereq_('./xhr');

            var decode64 = _dereq_('./utils').decode64;



            function SVGContainer(src) {

                this.src = src;

                this.image = null;

                var self = this;



                this.promise = this.hasFabric().then(function () {

                    return (self.isInline(src) ? Promise.resolve(self.inlineFormatting(src)) : XHR(src));

                }).then(function (svg) {

                    return new Promise(function (resolve) {

                        window.html2canvas.svg.fabric.loadSVGFromString(svg, self.createCanvas.call(self, resolve));

                    });

                });

            }



            SVGContainer.prototype.hasFabric = function () {

                return !window.html2canvas.svg || !window.html2canvas.svg.fabric ? Promise.reject(new Error("html2canvas.svg.js is not loaded, cannot render svg")) : Promise.resolve();

            };



            SVGContainer.prototype.inlineFormatting = function (src) {

                return (/^data:image\/svg\+xml;base64,/.test(src)) ? this.decode64(this.removeContentType(src)) : this.removeContentType(src);

            };



            SVGContainer.prototype.removeContentType = function (src) {

                return src.replace(/^data:image\/svg\+xml(;base64)?,/, '');

            };



            SVGContainer.prototype.isInline = function (src) {

                return (/^data:image\/svg\+xml/i.test(src));

            };



            SVGContainer.prototype.createCanvas = function (resolve) {

                var self = this;

                return function (objects, options) {

                    var canvas = new window.html2canvas.svg.fabric.StaticCanvas('c');

                    self.image = canvas.lowerCanvasEl;

                    canvas

                        .setWidth(options.width)

                        .setHeight(options.height)

                        .add(window.html2canvas.svg.fabric.util.groupSVGElements(objects, options))

                        .renderAll();

                    resolve(canvas.lowerCanvasEl);

                };

            };



            SVGContainer.prototype.decode64 = function (str) {

                return (typeof (window.atob) === "function") ? window.atob(str) : decode64(str);

            };



            module.exports = SVGContainer;



        }, {
            "./utils": 26,
            "./xhr": 28
        }],
        24: [function (_dereq_, module, exports) {

            var SVGContainer = _dereq_('./svgcontainer');



            function SVGNodeContainer(node, _native) {

                this.src = node;

                this.image = null;

                var self = this;



                this.promise = _native ? new Promise(function (resolve, reject) {

                    self.image = new Image();

                    self.image.onload = resolve;

                    self.image.onerror = reject;

                    self.image.src = "data:image/svg+xml," + (new XMLSerializer()).serializeToString(node);

                    if (self.image.complete === true) {

                        resolve(self.image);

                    }

                }) : this.hasFabric().then(function () {

                    return new Promise(function (resolve) {

                        window.html2canvas.svg.fabric.parseSVGDocument(node, self.createCanvas.call(self, resolve));

                    });

                });

            }



            SVGNodeContainer.prototype = Object.create(SVGContainer.prototype);



            module.exports = SVGNodeContainer;



        }, {
            "./svgcontainer": 23
        }],
        25: [function (_dereq_, module, exports) {

            var NodeContainer = _dereq_('./nodecontainer');



            function TextContainer(node, parent) {

                NodeContainer.call(this, node, parent);

            }



            TextContainer.prototype = Object.create(NodeContainer.prototype);



            TextContainer.prototype.applyTextTransform = function () {

                this.node.data = this.transform(this.parent.css("textTransform"));

            };



            TextContainer.prototype.transform = function (transform) {

                var text = this.node.data;

                switch (transform) {

                    case "lowercase":

                        return text.toLowerCase();

                    case "capitalize":

                        return text.replace(/(^|\s|:|-|\(|\))([a-z])/g, capitalize);

                    case "uppercase":

                        return text.toUpperCase();

                    default:

                        return text;

                }

            };



            function capitalize(m, p1, p2) {

                if (m.length > 0) {

                    return p1 + p2.toUpperCase();

                }

            }



            module.exports = TextContainer;



        }, {
            "./nodecontainer": 14
        }],
        26: [function (_dereq_, module, exports) {

            exports.smallImage = function smallImage() {

                return "";

            };



            exports.bind = function (callback, context) {

                return function () {

                    return callback.apply(context, arguments);

                };

            };



            /*

             * base64-arraybuffer

             * https://github.com/niklasvh/base64-arraybuffer

             *

             * Copyright (c) 2012 Niklas von Hertzen

             * Licensed under the MIT license.

             */



            exports.decode64 = function (base64) {

                var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

                var len = base64.length,
                    i, encoded1, encoded2, encoded3, encoded4, byte1, byte2, byte3;



                var output = "";



                for (i = 0; i < len; i += 4) {

                    encoded1 = chars.indexOf(base64[i]);

                    encoded2 = chars.indexOf(base64[i + 1]);

                    encoded3 = chars.indexOf(base64[i + 2]);

                    encoded4 = chars.indexOf(base64[i + 3]);



                    byte1 = (encoded1 << 2) | (encoded2 >> 4);

                    byte2 = ((encoded2 & 15) << 4) | (encoded3 >> 2);

                    byte3 = ((encoded3 & 3) << 6) | encoded4;

                    if (encoded3 === 64) {

                        output += String.fromCharCode(byte1);

                    } else if (encoded4 === 64 || encoded4 === -1) {

                        output += String.fromCharCode(byte1, byte2);

                    } else {

                        output += String.fromCharCode(byte1, byte2, byte3);

                    }

                }



                return output;

            };



            exports.getBounds = function (node) {

                if (node.getBoundingClientRect) {

                    var clientRect = node.getBoundingClientRect();

                    var width = node.offsetWidth == null ? clientRect.width : node.offsetWidth;

                    return {

                        top: clientRect.top,

                        bottom: clientRect.bottom || (clientRect.top + clientRect.height),

                        right: clientRect.left + width,

                        left: clientRect.left,

                        width: width,

                        height: node.offsetHeight == null ? clientRect.height : node.offsetHeight

                    };

                }

                return {};

            };



            exports.offsetBounds = function (node) {

                var parent = node.offsetParent ? exports.offsetBounds(node.offsetParent) : {
                    top: 0,
                    left: 0
                };



                return {

                    top: node.offsetTop + parent.top,

                    bottom: node.offsetTop + node.offsetHeight + parent.top,

                    right: node.offsetLeft + parent.left + node.offsetWidth,

                    left: node.offsetLeft + parent.left,

                    width: node.offsetWidth,

                    height: node.offsetHeight

                };

            };



            exports.parseBackgrounds = function (backgroundImage) {

                var whitespace = ' \r\n\t',

                    method, definition, prefix, prefix_i, block, results = [],

                    mode = 0,
                    numParen = 0,
                    quote, args;

                var appendResult = function () {

                    if (method) {

                        if (definition.substr(0, 1) === '"') {

                            definition = definition.substr(1, definition.length - 2);

                        }

                        if (definition) {

                            args.push(definition);

                        }

                        if (method.substr(0, 1) === '-' && (prefix_i = method.indexOf('-', 1) + 1) > 0) {

                            prefix = method.substr(0, prefix_i);

                            method = method.substr(prefix_i);

                        }

                        results.push({

                            prefix: prefix,

                            method: method.toLowerCase(),

                            value: block,

                            args: args,

                            image: null

                        });

                    }

                    args = [];

                    method = prefix = definition = block = '';

                };

                args = [];

                method = prefix = definition = block = '';

                backgroundImage.split("").forEach(function (c) {

                    if (mode === 0 && whitespace.indexOf(c) > -1) {

                        return;

                    }

                    switch (c) {

                        case '"':

                            if (!quote) {

                                quote = c;

                            } else if (quote === c) {

                                quote = null;

                            }

                            break;

                        case '(':

                            if (quote) {

                                break;

                            } else if (mode === 0) {

                                mode = 1;

                                block += c;

                                return;

                            } else {

                                numParen++;

                            }

                            break;

                        case ')':

                            if (quote) {

                                break;

                            } else if (mode === 1) {

                                if (numParen === 0) {

                                    mode = 0;

                                    block += c;

                                    appendResult();

                                    return;

                                } else {

                                    numParen--;

                                }

                            }

                            break;



                        case ',':

                            if (quote) {

                                break;

                            } else if (mode === 0) {

                                appendResult();

                                return;

                            } else if (mode === 1) {

                                if (numParen === 0 && !method.match(/^url$/i)) {

                                    args.push(definition);

                                    definition = '';

                                    block += c;

                                    return;

                                }

                            }

                            break;

                    }



                    block += c;

                    if (mode === 0) {

                        method += c;

                    } else {

                        definition += c;

                    }

                });



                appendResult();

                return results;

            };



        }, {}],
        27: [function (_dereq_, module, exports) {

            var GradientContainer = _dereq_('./gradientcontainer');



            function WebkitGradientContainer(imageData) {

                GradientContainer.apply(this, arguments);

                this.type = imageData.args[0] === "linear" ? GradientContainer.TYPES.LINEAR : GradientContainer.TYPES.RADIAL;

            }



            WebkitGradientContainer.prototype = Object.create(GradientContainer.prototype);



            module.exports = WebkitGradientContainer;



        }, {
            "./gradientcontainer": 9
        }],
        28: [function (_dereq_, module, exports) {

            function XHR(url) {

                return new Promise(function (resolve, reject) {

                    var xhr = new XMLHttpRequest();

                    xhr.open('GET', url);



                    xhr.onload = function () {

                        if (xhr.status === 200) {

                            resolve(xhr.responseText);

                        } else {

                            reject(new Error(xhr.statusText));

                        }

                    };



                    xhr.onerror = function () {

                        reject(new Error("Network Error"));

                    };



                    xhr.send();

                });

            }



            module.exports = XHR;



        }, {}]
    }, {}, [4])(4)

});